assertEquals((byte) 'S', SMBUtil.SMB2_HEADER[1]);
        assertEquals((byte) 'M', SMBUtil.SMB2_HEADER[2]);
        assertEquals((byte) 'B', SMBUtil.SMB2_HEADER[3]);

        // Verify structure size (64 in little-endian)
        assertEquals((byte) 64, SMBUtil.SMB2_HEADER[4]);
        assertEquals((byte) 0x00, SMBUtil.SMB2_HEADER[5]);
    }

    @ParameterizedTest

        writeLittleEndianInt(dos, 0); // unusedChars
        writeLittleEndianInt(dos, totalChars); // usedChars

        // Write the actual characters (as shorts in little-endian)
        for (char c : testString.toCharArray()) {
            writeLittleEndianShort(dos, (short) c);
        }

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

        DummyResponse d = new DummyResponse();
        // Construct a minimal wire format buffer
        byte[] buf = new byte[32];
        int idx = 0;
        // Write values little-endian
        buf[idx++] = 5; // totalParameterCount low byte
        buf[idx++] = 0; // totalParameterCount high byte -> value 5
        buf[idx++] = 3; // totalDataCount low
        buf[idx++] = 0; // totalDataCount high

        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_PEEK_NAMED_PIPE, buffer[offset]);
        assertEquals((byte) 0x00, buffer[offset + 1]);

        // Verify FID is written correctly (little-endian)
        int writtenFid = SMBUtil.readInt2(buffer, offset + 2);
        assertEquals(TEST_FID, writtenFid);
    }

    @Test
    @DisplayName("writeSetupWireFormat should handle buffer boundary")

        @DisplayName("Should handle signed byte value correctly")
        void testReadBytesWireFormatSignedByteValue() {
            // Given
            byte[] buffer = new byte[10];
            // Write 4 in little-endian format
            buffer[0] = 0x04;
            buffer[1] = 0x00;

            // When & Then
            assertDoesNotThrow(() -> {
                int bytesRead = response.readBytesWireFormat(buffer, 0);

  public void writeTo(OutputStream out) throws IOException {
    // Serial form:
    // 1 signed byte for the strategy
    // 1 unsigned byte for the number of hash functions
    // 1 big endian int, the number of longs in our bitset
    // N big endian longs of our bitset
    DataOutputStream dout = new DataOutputStream(out);
    dout.writeByte(SignedBytes.checkedCast(strategy.ordinal()));

    }
  }

  /**
   * Returns an address from a <b>little-endian ordered</b> byte array (the opposite of what {@link
   * InetAddress#getByAddress} expects).
   *
   * <p>IPv4 address byte array must be 4 bytes long and IPv6 byte array must be 16 bytes long.
   *
   * @param addr the raw IP address in little-endian byte order
   * @return an InetAddress object created from the raw IP address

        // When
        byte[] messageBytes = type3.toByteArray();

        // Then
        assertTrue(messageBytes.length >= 12);
        // Message type should be 3 (little endian)
        assertEquals(3, messageBytes[8] & 0xFF);
        assertEquals(0, messageBytes[9] & 0xFF);
        assertEquals(0, messageBytes[10] & 0xFF);
        assertEquals(0, messageBytes[11] & 0xFF);
    }

            int bytesEncoded = buffer.encode(dst, 0);

            // Manually verify the encoded bytes
            assertEquals(buffer.size(), bytesEncoded);

            // Check referral level (little-endian)
            assertEquals(4, dst[0] & 0xFF);
            assertEquals(0, dst[1] & 0xFF);

            // Check path starts at byte 2
            byte[] expectedPathBytes = path.getBytes(StandardCharsets.UTF_16LE);

    <magic priority="50">
      <!-- MM.* = Big endian (M=Motorola) and 0x002a in big endian    -->
      <match value="MM\x00\x2a" type="string" offset="0"/>
      <!-- II*. = Little endian (I=Intel) and 0x002a in little endian -->
      <match value="II\x2a\x00" type="string" offset="0"/>
      <!-- MM.+ = Big endian (M=Motorola) and 0x002a in big endian-->
      <match value="MM\x00\x2b" type="string" offset="0"/>