0x84, 0xcb, 0x2d, 0x9f, 0xae, 0x2d, 0x67, 0xfd, 0x96, 0xfb, 0x92, 0x6c, 0x19,
		0x8e, 0x7, 0x73, 0x99, 0xfd, 0xc8, 0x15, 0xc0, 0xaf, 0x9, 0x7d, 0xde, 0x5a,
		0xad, 0xef, 0xf4, 0x4d, 0xe7, 0xe, 0x82, 0x7f, 0x48, 0x78, 0x43, 0x24, 0x39,
		0xbf, 0xee, 0xb9, 0x60, 0x68, 0xd0, 0x47, 0x4f, 0xc5, 0xd, 0x6d, 0x90, 0xbf,
		0x3a, 0x98, 0xdf, 0xaf, 0x10, 0x40, 0xc8, 0x9c, 0x2, 0xd6, 0x92, 0xab, 0x3b,

  public void testIsWellFormed_4BytesSamples() {
    // Valid 4 byte.
    assertWellFormed(0xF0, 0xA4, 0xAD, 0xA2);
    // Bad trailing bytes
    assertNotWellFormed(0xF0, 0xA4, 0xAD, 0x7F);
    assertNotWellFormed(0xF0, 0xA4, 0xAD, 0xC0);
    // Special cases for byte2
    assertNotWellFormed(0xF0, 0x8F, 0xAD, 0xA2);
    assertNotWellFormed(0xF4, 0x90, 0xAD, 0xA2);
  }

  /** Tests some hard-coded test cases. */

        byte[] data = new byte[] { 1, 2 };

        // Use a type that's not SESSION_MESSAGE or SESSION_KEEP_ALIVE
        byte[] unknownHeader = new byte[] { (byte) 0x90, 0, 0, 0 };

        byte[] fullData = concat(unknownHeader, // Unknown packet type - will continue to next packet
                messageHeader(2), data);
        InputStream in = new ByteArrayInputStream(fullData);

        void testDcerpcConcMpx() {
            assertEquals(0x10, DcerpcConstants.DCERPC_CONC_MPX, "DCERPC_CONC_MPX should be 0x10");
        }

        @Test
        @DisplayName("DCERPC_DID_NOT_EXECUTE should have correct value")
        void testDcerpcDidNotExecute() {
            assertEquals(0x20, DcerpcConstants.DCERPC_DID_NOT_EXECUTE, "DCERPC_DID_NOT_EXECUTE should be 0x20");
        }

        @Test

        byte[] wireData = new byte[] { 0x10, 0x00, // StructureSize (must be 16)
                0x01, // ShareType (DISK)
                0x00, // Reserved
                0x01, 0x00, 0x00, 0x00, // ShareFlags
                0x08, 0x00, 0x00, 0x00, // Capabilities
                (byte) 0xFF, 0x01, 0x1F, 0x00 // MaximalAccess
        };

        // When

        // Bit 2: active (1)
        // Bit 1: permanent (1)

        // MAC address
        byte[] testMac = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
        System.arraycopy(testMac, 0, src, srcIndex + 19, 6);

        // Statistics
        byte[] stats = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
        System.arraycopy(stats, 0, src, srcIndex + 25, 6);

        response.readRDataWireFormat(src, srcIndex);

    void testSmbFlags() {
        assertEquals(0x00, SmbConstants.FLAGS_NONE);
        assertEquals(0x01, SmbConstants.FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK);
        assertEquals(0x02, SmbConstants.FLAGS_RECEIVE_BUFFER_POSTED);
        assertEquals(0x08, SmbConstants.FLAGS_PATH_NAMES_CASELESS);
        assertEquals(0x10, SmbConstants.FLAGS_PATH_NAMES_CANONICALIZED);
        assertEquals(0x20, SmbConstants.FLAGS_OPLOCK_REQUESTED_OR_GRANTED);

     */
    int FLAGS_PATH_NAMES_CANONICALIZED = 0x10;
    /**
     * Opportunistic lock requested or granted flag.
     */
    int FLAGS_OPLOCK_REQUESTED_OR_GRANTED = 0x20;
    /**
     * Notify client of any action which modified the file flag.
     */
    int FLAGS_NOTIFY_OF_MODIFY_ACTION = 0x40;
    /**
     * Message is a response from server flag.
     */
    int FLAGS_RESPONSE = 0x80;

    /**

          when {
            b == 0x80 -> {
              // 10000000
              throw IOException("index == 0")
            }

            b and 0x80 == 0x80 -> {
              // 1NNNNNNN
              val index = readInt(b, PREFIX_7_BITS)
              readIndexedHeader(index - 1)
            }

            b == 0x40 -> {
              // 01000000

        PrintStream ps = new PrintStream(baos);

        // Test with control characters and printable characters
        byte[] data = { 0x00, 0x01, 0x09, 0x0A, 0x0D, 0x1F, // Control characters
                0x20, 0x41, 0x42, 0x7E, // Printable characters
                (byte) 0x7F, (byte) 0x80, (byte) 0xFF // Extended/control
        };

        Hexdump.hexdump(ps, data, 0, data.length);
        String output = baos.toString();