// Create a buffer with sample data
            byte[] buffer = new byte[100];
            // Fill with some test data
            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) (i % 256);
            }

            int result = resp.readDataWireFormat(buffer, 0, 40);
            assertNotNull(resp.info);

        bufferIndex += 8;

        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.fileAttributes = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        bufferIndex += 4; // Reserved2

 *
 * <p><a id="bitEquals"></a>This class compares primitive {@code double} values in methods such as
 * {@link #compareAndSet} by comparing their bitwise representation using {@link
 * Double#doubleToRawLongBits}, which differs from both the primitive double {@code ==} operator and
 * from {@link Double#equals}, as if implemented by:
 *
 * {@snippet :
 * static boolean bitEquals(double x, double y) {
 *   long xBits = Double.doubleToRawLongBits(x);

		gotOK := compareAPI(buf, tt.features, tt.required, tt.exception)
		if gotOK != tt.ok {
			t.Errorf("%s: ok = %v; want %v", tt.name, gotOK, tt.ok)
		}
		if got := buf.String(); got != tt.out {
			t.Errorf("%s: output differs\nGOT:\n%s\nWANT:\n%s", tt.name, got, tt.out)
		}
	}
}

func TestSkipInternal(t *testing.T) {
	if *flagCheck {
		// not worth repeating in -check
		t.Skip("skipping with -check set")
	}

        this.server.smaxMpxCount = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.server.maxNumberVcs = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.server.maxBufferSize = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.server.maxRawSize = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        assertEquals(16, SMBUtil.readInt2(buffer, 4));

        // NameLength field (2 bytes) - should be 4 for "RqLs"
        assertEquals(4, SMBUtil.readInt2(buffer, 6));

        // Reserved field (2 bytes) - should be 0
        assertEquals(0, SMBUtil.readInt2(buffer, 8));

        // DataOffset field (2 bytes) - should be 24 (16 header + 4 name + 4 padding)
        assertEquals(24, SMBUtil.readInt2(buffer, 10));

  ): Long {
    var byteCount = 0L
    val buffer: Buffer = if (countBytes) Buffer() else sink!!.buffer

    for (i in 0 until encodedNames.size) {
      if (i > 0) buffer.writeByte('&'.code)
      buffer.writeUtf8(encodedNames[i])
      buffer.writeByte('='.code)
      buffer.writeUtf8(encodedValues[i])
    }

    if (countBytes) {
      byteCount = buffer.size
      buffer.clear()
    }

    return byteCount
  }

        byte[] buffer = new byte[512];

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, 0);

        // Then
        assertTrue(bytesWritten > 0);

        // Verify structure size
        assertEquals(36, SMBUtil.readInt2(buffer, 0));

        // Verify dialect count
        assertEquals(3, SMBUtil.readInt2(buffer, 2)); // SMB210, SMB300, SMB302

    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        this.fid = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        this.typeOfLock = buffer[bufferIndex];

        if ((this.typeOfLock & 0x10) == 0x10) {
            this.largeFile = true;
        }

        this.newOpLockLevel = buffer[bufferIndex + 1];
        bufferIndex += 2;

    /**
     * Finds the null termination in a UTF-16LE encoded string buffer.
     *
     * @param buffer the byte buffer to search
     * @param bufferIndex the starting position in the buffer
     * @param maxLen the maximum length to search
     * @return position of terminating null bytes
     */
    public static int findUNITermination(final byte[] buffer, final int bufferIndex, final int maxLen) {
        int len = 0;