// By default at least 128 entries in single getdents call (1MiB buffer)
var (
	direntPool = bpool.Pool[*[]byte]{
		New: func() *[]byte {
			buf := make([]byte, blockSize*128)
			return &buf
		},
	}

	direntNamePool = bpool.Pool[*[]byte]{
		New: func() *[]byte {
			buf := make([]byte, blockSize)
			return &buf
		},
	}
)

// unexpectedFileMode is a sentinel (and bogus) os.FileMode

        // Using little-endian byte order as per SMBUtil.readInt2
        byte[] buf = new byte[12];
        buf[0] = 0x34; // Low byte
        buf[1] = 0x12; // High byte
        int written = resp.readParameterWordsWireFormat(buf, 0);

        assertEquals(8, written, "Expected readParameterWordsWireFormat to advance 8 bytes");

        byte[] mechToken = new byte[] { 0x01, 0x02, 0x03 };
        byte[] mic = new byte[] { (byte) 0xFE, 0x55 };

        NegTokenInit init = new NegTokenInit(mechs, flags, mechToken, mic);
        byte[] bytes = init.toByteArray();

        NegTokenInit parsed = new NegTokenInit(bytes);

	}

	object := "object"
	data := bytes.Repeat([]byte("a"), smallFileThreshold*32)
	z := obj.(*erasureServerPools)

	erasureDisks, err := z.GetDisks(0, 0)
	if err != nil {
		t.Fatal(err)
	}

	for i, test := range testCases {
		t.Run(fmt.Sprintf("case-%d", i), func(t *testing.T) {
			_, err = obj.PutObject(ctx, bucket, object, mustGetPutObjReader(t, bytes.NewReader(data), int64(len(data)), "", ""), ObjectOptions{})

    void testReadULong() {
        byte[] a = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04 };
        int result = NtlmMessage.readULong(a, 0);
        assertEquals(0x04030201, result, "ULong should be little‑endian");
    }

    @Test
    @DisplayName("readUShort correctly interprets little endian")
    void testReadUShort() {
        byte[] a = new byte[] { (byte) 0xAA, (byte) 0xBB };

     *
     * @return true if the response has a body (either as bytes or file), false otherwise
     */
    public boolean hasResponseBody() {
        return responseBodyBytes != null || responseBodyFile != null;
    }

    /**
     * Gets the response body as an InputStream.
     * If the response body is stored as bytes, returns a ByteArrayInputStream.

     *
     * @return a cryptographically secure random salt
     */
    public byte[] generatePreauthSalt() {
        byte[] salt = new byte[SALT_SIZE];
        secureRandom.nextBytes(salt);
        log.debug("Generated new preauth salt of {} bytes", salt.length);
        return salt;
    }

    /**
     * Initializes preauth integrity context for a new session.
     *

            log.debug("Data too small for compression ({} bytes), returning uncompressed", length);
            byte[] result = new byte[length];
            System.arraycopy(data, offset, result, 0, length);
            return result;
        }
        if (length > MAX_COMPRESSION_SIZE) {
            throw new CIFSException("Data too large for compression: " + length + " bytes");
        }

        switch (algorithm) {

        byte[] encoded = encodeUnicode(msg);
        assertEquals(4, encoded.length, "Encoded Unicode string should be 4 bytes");

        // Verify little-endian encoding
        assertEquals((byte) 0xA1, encoded[0], "First byte of first character");
        assertEquals((byte) 0x00, encoded[1], "Second byte of first character");
        assertEquals((byte) 0xA2, encoded[2], "First byte of second character");

            // Arrange
            Smb2LogoffResponse resp = newResponse();
            byte[] buffer = new byte[8];
            byte[] original = buffer.clone();

            // Act
            int written = resp.writeBytesWireFormat(buffer, index);

            // Assert
            assertEquals(0, written, "Should report 0 bytes written");
            assertArrayEquals(original, buffer, "Buffer must remain unchanged");
        }