}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z BatchJobSize) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendInt64(o, int64(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BatchJobSize) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 int64
		zb0001, bts, err = msgp.ReadInt64Bytes(bts)
		if err != nil {

     */
    static Stream<Arguments> decodeProvider() {
        return Stream.of(Arguments.of("", new byte[0]), Arguments.of("QQ==", new byte[] { (byte) 0x41 }), // "A"
                Arguments.of("QUI=", new byte[] { (byte) 0x41, (byte) 0x42 }), // "AB"
                Arguments.of("TWFu", "Man".getBytes()), Arguments.of("AAAA", new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00 }), // all zeros

        // For Unicode: 1 byte (initial null in writeBytesWireFormat)
        // + potential 1 byte alignment (in writeString) + fileName.length() * 2 + 2 bytes (terminating nulls)
        // Since headerStart is 0 and dstIndex starts at 1 (after initial null), (1-0)%2=1, so alignment byte added
        // Total: 1 + 1 + 12*2 + 2 = 28 bytes
        byte[] dst = new byte[30]; // Use extra buffer space to avoid index errors

    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 };

            when(mockNdrBuffer.dec_ndr_small()).thenReturn((int) (byte) 0x11, (int) (byte) 0x22, // clock seq bytes
                    (int) (byte) 0xAA, (int) (byte) 0xBB, (int) (byte) 0xCC, (int) (byte) 0xDD, (int) (byte) 0xEE, (int) (byte) 0xFF // node bytes
            );
            when(mockNdrBuffer.derive(anyInt())).thenReturn(mockNdrBuffer);

            // When: Decoding the UUID

        int written = req.writeBytesWireFormat(buf, offset);

        // Assert: should write exactly 4 bytes
        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test

    outputStreamOpened = true;
    bytes.reset(); // truncate
    return new Out();
  }

  private final class Out extends TestOutputStream {

    Out() throws IOException {
      super(bytes, options);
    }

    @Override
    public void close() throws IOException {
      outputStreamClosed = true;
      super.close();
    }
  }

        byte[] src = new byte[10];
        int srcIndex = 0;

        // Simulate groupName = false, nodeType = 0
        src[srcIndex] = (byte) 0x00;
        src[srcIndex + 1] = (byte) 0x00;

        // Simulate address = 0.0.0.0
        src[srcIndex + 2] = (byte) 0x00;
        src[srcIndex + 3] = (byte) 0x00;
        src[srcIndex + 4] = (byte) 0x00;
        src[srcIndex + 5] = (byte) 0x00;

func init() {
	testBytes = make([]byte, N)
	for i := 0; i < N; i++ {
		testBytes[i] = 'a' + byte(i%26)
	}
	testString = string(testBytes)
}

// Verify that contents of buf match the string s.
func check(t *testing.T, testname string, buf *Buffer, s string) {
	bytes := buf.Bytes()
	str := buf.String()
	if buf.Len() != len(bytes) {

    void testReadLengthMaximum() {
        byte[] src = { (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF };
        int length = SessionServicePacket.readLength(src, 0);

        assertEquals(0x01FFFF, length);
    }

    @Test
    @DisplayName("readLength should handle zero length")
    void testReadLengthZero() {
        byte[] src = { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };