assertFalse(config.isForceExtendedSecurity());
    }

    @Test
    @DisplayName("Test buffer configuration getters")
    void testBufferConfigurationGetters() {
        assertEquals(0xFFFF - 512, config.getTransactionBufferSize());
        assertEquals(0x10000, config.getMaximumBufferSize());
        assertEquals(16, config.getBufferCacheSize());
        assertEquals(200, config.getListCount());

        @Test
        @DisplayName("Should handle compound with final response")
        void testCompoundFinalResponse() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[512];
            System.arraycopy(SMBUtil.SMB2_HEADER, 0, buffer, 0, 4);
            SMBUtil.writeInt4(0, buffer, 20); // nextCommand = 0 (final)

            testMessage.setBytesRead(10);

	magicGNU, versionGNU     = "ustar ", " \x00"
	magicUSTAR, versionUSTAR = "ustar\x00", "00"
	trailerSTAR              = "tar\x00"
)

// Size constants from various tar specifications.
const (
	blockSize  = 512 // Size of each block in a tar stream
	nameSize   = 100 // Max length of the name field in USTAR format
	prefixSize = 155 // Max length of the prefix field in USTAR format

		objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
		if err != nil {
			return err
		}

		// Calculate a hash of the key for the id of the ES document.
		// Id's are limited to 512 bytes in V7+, so we need to do this.
		var keyHash string
		{
			key := eventData.S3.Bucket.Name + "/" + objectName
			if target.client.isAtleastV7() {

    }

    @Test
    @DisplayName("Test writeParameterWordsWireFormat with large buffer offset")
    void testWriteParameterWordsWireFormatLargeOffset() {
        byte[] dst = new byte[512];
        int startOffset = 100;

        // Set up transaction parameters
        transaction.setMaxSetupCount((byte) 3);
        transaction.setTotalParameterCount(500);
        transaction.setTotalDataCount(1000);

        super(config, command);
        this.subCommand = subCommand;
        this.maxDataCount = config.getTransactionBufferSize() - 512;
        this.maxParameterCount = 1024;
        this.primarySetupOffset = PRIMARY_SETUP_OFFSET;
        this.secondaryParameterOffset = SECONDARY_PARAMETER_OFFSET;
    }

    /**

pkg syscall (freebsd-arm64), const BPF_T_MICROTIME_MONOTONIC = 512
pkg syscall (freebsd-arm64), const BPF_T_MICROTIME_MONOTONIC ideal-int
pkg syscall (freebsd-arm64), const BPF_T_MICROTIME_MONOTONIC_FAST = 768
pkg syscall (freebsd-arm64), const BPF_T_MICROTIME_MONOTONIC_FAST ideal-int
pkg syscall (freebsd-arm64), const BPF_T_MONOTONIC = 512
pkg syscall (freebsd-arm64), const BPF_T_MONOTONIC ideal-int

pkg debug/elf, const R_AARCH64_LD64_GOTOFF_LO15 R_AARCH64
pkg debug/elf, const R_AARCH64_LD64_GOTPAGE_LO15 = 313
pkg debug/elf, const R_AARCH64_LD64_GOTPAGE_LO15 R_AARCH64
pkg debug/elf, const R_AARCH64_TLSGD_ADR_PREL21 = 512
pkg debug/elf, const R_AARCH64_TLSGD_ADR_PREL21 R_AARCH64
pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G0_NC = 516
pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G0_NC R_AARCH64
pkg debug/elf, const R_AARCH64_TLSGD_MOVW_G1 = 515

    @ValueSource(ints = { 0, 10, 50, 100 })
    @DisplayName("writeBytesWireFormat should work at different offsets")
    void testWriteBytesWireFormatAtDifferentOffsets(int offset) {
        byte[] buffer = new byte[512];

        int written = request.writeBytesWireFormat(buffer, offset);

        assertEquals(24, written);
        assertEquals(24, SMBUtil.readInt2(buffer, offset));

func updateDriveIOStats(currentStats madmin.DiskIOStats, latestStats madmin.DiskIOStats, labels map[string]string) {
	sectorSize := uint64(512)
	kib := float64(1 << 10)
	diffInSeconds := time.Now().UTC().Sub(lastDriveStatsRefresh).Seconds()
	if diffInSeconds == 0 {
		// too soon to update the stats
		return
	}