attributes.put("sectanchors", true);
            attributes.put("sectlinks", true);
            attributes.put("linkattrs", true);
            attributes.put("reproducible", "");
            attributes.put("docinfo", "");
            attributes.put("lang", "en-US");
            attributes.put("encoding", "utf-8");
            attributes.put("idprefix", "");
            attributes.put("website", "https://gradle.org");

        lsarpc.LsarQosInfo qosInfo = new lsarpc.LsarQosInfo();
        qosInfo.length = 10;
        qosInfo.impersonation_level = 1;
        qosInfo.context_mode = 2;
        qosInfo.effective_only = 3;

        qosInfo.encode(mockNdrBuffer);

        // Verify encode calls
        verify(mockNdrBuffer).align(4);
        verify(mockNdrBuffer).enc_ndr_long(qosInfo.length);

// - madmin.TraceInfo type is asked by opts
func shouldTrace(trcInfo madmin.TraceInfo, opts madmin.ServiceTraceOpts) (shouldTrace bool) {
	// Reject all unwanted types.
	want := opts.TraceTypes()
	if !want.Contains(trcInfo.TraceType) {
		return false
	}

	isHTTP := trcInfo.TraceType.Overlaps(madmin.TraceInternal|madmin.TraceS3) && trcInfo.HTTP != nil

	// Check latency...

		func(ctx context.Context) (DiskInfo, error) {
			dcinfo := DiskInfo{}
			di, root, err := getDiskInfo(s.drivePath)
			if err != nil {
				return dcinfo, err
			}
			dcinfo.RootDisk = root
			dcinfo.Major = di.Major
			dcinfo.Minor = di.Minor
			dcinfo.Total = di.Total
			dcinfo.Free = di.Free
			dcinfo.Used = di.Used
			dcinfo.UsedInodes = di.Files - di.Ffree
			dcinfo.FreeInodes = di.Ffree
			dcinfo.FSType = di.FSType

	headBucketRPC                  = grid.NewSingleHandler[*grid.MSS, *VolInfo](grid.HandlerHeadBucket, grid.NewMSS, func() *VolInfo { return &VolInfo{} })
	healBucketRPC                  = grid.NewSingleHandler[*grid.MSS, *grid.JSON[madmin.HealResultItem]](grid.HandlerHealBucket, grid.NewMSS, madminHealResultItem.NewJSON)

        request.setFileInfoClass((byte) 0x04);
        request.setAdditionalInformation(0x12345678);

        Encodable mockInfo = mock(Encodable.class);
        when(mockInfo.encode(any(byte[].class), anyInt())).thenReturn(20);
        when(mockInfo.size()).thenReturn(20);
        request.setInfo(mockInfo);

        // Set up header start for offset calculation
        try {

            // Create a mock of the Info interface
            Info mockInfo = mock(Info.class);

            // Set up mock behavior
            when(mockInfo.getAttributes()).thenReturn(0x20);
            when(mockInfo.getSize()).thenReturn(1024L);
            when(mockInfo.getCreateTime()).thenReturn(1000000L);
            when(mockInfo.getLastWriteTime()).thenReturn(2000000L);

            // Use the mock

		t.Fatalf("failed to query data, got error %v", err)
	}

	AssertEqual(t, result.Roles, data.Roles)
	AssertEqual(t, result.JobInfo.Location, data.JobInfo.Location)
}

// Test for: panic when serializer field with any type is nil
func TestSerializerWithAnyType(t *testing.T) {
	type ProductWithAny struct {
		gorm.Model
		Name string
		Data any `gorm:"serializer:json"`
	}

* **TCP no sabe acerca de "dominios"**. Solo sobre direcciones IP.
    * La información sobre el **dominio específico** solicitado va en los **datos HTTP**.
* Los **certificados HTTPS** "certifican" un **cierto dominio**, pero el protocolo y la encriptación ocurren a nivel de TCP, **antes de saber** con cuál dominio se está tratando.
* **Por defecto**, eso significaría que solo puedes tener **un certificado HTTPS por dirección IP**.

			srcInfo.Reader.Close() // We are not interested in the reader stream at this point close it.
			return srcSet.CopyObject(ctx, srcBucket, srcObject, dstBucket, dstObject, srcInfo, srcOpts, dstOpts)
		}
		// Destination is not versioned and source version ID is empty
		// perform an in-place update.
		if !dstOpts.Versioned && srcOpts.VersionID == "" {