public AvSingleHost(final Configuration cfg) {
        this(new byte[8], cfg.getMachineId());
    }

    /**
     * Constructs an AvSingleHost with custom data and machine ID
     *
     * @param customData custom data for the single host (8 bytes)
     * @param machineId the machine identifier (32 bytes)
     */
    public AvSingleHost(final byte[] customData, final byte[] machineId) {
        this(encode(customData, machineId));
    }

	req, err := http.NewRequest(http.MethodGet, "http://localhost:9000/bucket/name?uploadId=upload&partNumber=1", http.NoBody)
	if err != nil {
		b.Fatal(err)
	}

	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
	b.ReportAllocs()
	// the actual benchmark for PutObject starts here. Reset the benchmark timer.
	b.ResetTimer()

	if err := req.ParseForm(); err != nil {
		b.Fatal(err)
	}

		"Average dial time of internode TCP calls in nanoseconds")
	internodeSentBytesTotalMD = NewCounterMD(internodeSentBytesTotal,
		"Total number of bytes sent to other peer nodes")
	internodeRecvBytesTotalMD = NewCounterMD(internodeRecvBytesTotal,
		"Total number of bytes received from other peer nodes")
)

// loadNetworkInternodeMetrics - reads internode network metrics.
//
// This is a `MetricsLoaderFn`.

		if err != nil {
			f.Fatalf("failed to read testdata: %s", err)
		}
		f.Add(b)
	}

	f.Fuzz(func(t *testing.T, b []byte) {
		r, err := NewReader(bytes.NewReader(b), int64(len(b)))
		if err != nil {
			return
		}

		type file struct {
			header  *FileHeader
			content []byte
		}
		files := []file{}

		for _, f := range r.File {
			fr, err := f.Open()
			if err != nil {
				continue
			}

		f:      formatGzip,
	},
	{
		// Zstd default header.
		header: []byte{0x28, 0xb5, 0x2f, 0xfd},
		f:      formatZstd,
	},
	{
		// Zstd skippable frame header.
		header: []byte{0x2a, 0x4d, 0x18},
		f:      formatZstd,
	},
	{
		// LZ4
		header: []byte{0x4, 0x22, 0x4d, 0x18},
		f:      formatLZ4,
	},
	{
		// Snappy/S2 stream
		header: []byte{0xff, 0x06, 0x00, 0x00},
		f:      formatS2,
	},
	{

        // Create inner content with OID and magic bytes but wrong tag after
        ByteArrayOutputStream innerContent = new ByteArrayOutputStream();
        ASN1ObjectIdentifier kerberosOid = new ASN1ObjectIdentifier(KerberosConstants.KERBEROS_OID);
        innerContent.write(kerberosOid.getEncoded());
        innerContent.write(0x01); // magic byte 1
        innerContent.write(0x00); // magic byte 2

    private byte[] challenge;
    private String target;
    private byte[] context;
    private byte[] targetInformation;

    private static final Map<String, byte[]> TARGET_INFO_CACHE = new HashMap<>();

    private static byte[] getDefaultTargetInfo(final CIFSContext tc) {
        final String domain = tc.getConfig().getDefaultDomain();
        byte[] ti = TARGET_INFO_CACHE.get(domain);

	healEntrySuccess := func(sz uint64) healEntryResult {
		return healEntryResult{
			bytes:   sz,
			success: true,
		}
	}

	healEntryFailure := func(sz uint64) healEntryResult {
		return healEntryResult{
			bytes: sz,
		}
	}

	healEntrySkipped := func(sz uint64) healEntryResult {
		return healEntryResult{
			bytes:   sz,
			skipped: true,
		}
	}

        assertEquals((byte) 0xCC, buffer[4]);
        assertEquals((byte) 0xCC, buffer[5]);
        assertEquals((byte) 0xCC, buffer[6]);
        assertEquals((byte) 0xCC, buffer[7]);

        // FileId (16 bytes) - should match our test file ID
        byte[] wireFileId = new byte[16];
        System.arraycopy(buffer, 8, wireFileId, 0, 16);
        assertArrayEquals(testFileId, wireFileId);

		// Incomplete; get more bytes.
		return 0, nil, nil
	}

	// We have a real UTF-8 encoding error. Return a properly encoded error rune
	// but advance only one byte. This matches the behavior of a range loop over
	// an incorrectly encoded string.
	return 1, errorRune, nil
}

// dropCR drops a terminal \r from the data.
func dropCR(data []byte) []byte {
	if len(data) > 0 && data[len(data)-1] == '\r' {