* Test constructor with malformed data (too short).
     */
    @Test
    void testConstructorMalformedData() {
        // Prepare data (only 2 bytes, less than an int)
        byte[] data = new byte[] { 0x01, 0x02 };

        // Verify that PACDecodingException is thrown
        assertThrows(PACDecodingException.class, () -> {
            new PacSignature(data);
        });
    }

    /**

        assertEquals(2, written, "setup packet should write 2 bytes");
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, buf[0], "first byte should be subCommand");
        assertEquals((byte) 0x00, buf[1], "second byte should be zero");
    }

    @Test
    @DisplayName("writeParametersWireFormat writes the information level as 2-byte little endian")
    void testWriteParametersWireFormat() {

        when(logonInfo.getHomeDrive()).thenReturn("H:");
        when(logonInfo.getLogonScript()).thenReturn("logon.bat");
        when(logonInfo.getUserAccountControl()).thenReturn(0x200);
        when(logonInfo.getUserFlags()).thenReturn(0);
        when(logonInfo.getUserSid()).thenReturn(userSid);
        when(logonInfo.getGroupSid()).thenReturn(new SID("S-1-5-21-1-2-3-513"));

        subCommand = NET_SERVER_ENUM2; // not really true be used by upper logic
        name = "\\PIPE\\LANMAN";

        maxParameterCount = 8;
        maxDataCount = 16384;
        maxSetupCount = (byte) 0x00;
        setupCount = 0;
        timeout = 5000;
    }

    @Override
    void reset(final int key, final String lastName) {
        super.reset();
        this.lastName = lastName;
    }

    @Override

        assertEquals(8, getFieldValue(netServerEnum2, "maxParameterCount"));
        assertEquals(16384, getFieldValue(netServerEnum2, "maxDataCount"));
        assertEquals((byte) 0x00, getFieldValue(netServerEnum2, "maxSetupCount"));
        assertEquals(0, getFieldValue(netServerEnum2, "setupCount"));
        assertEquals(5000, getFieldValue(netServerEnum2, "timeout"));
    }

    @Test

        byte[] bufferData = buf.getBuffer();
        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */

        private final int flags;

        /** Flag indicating IPv4 address type */
        public static final int IPV4 = 0x01;
        /** Flag indicating IPv6 address type */
        public static final int IPV6 = 0x02;

        /**
         * Creates a new witness IP address.
         *
         * @param address the IP address
         */
        public WitnessIPAddress(InetAddress address) {
            this.address = address;

  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. */

        }
    }

    /* --- flag handling -------------------------------- */
    @Test
    void testFlagSetAndUnset() {
        TestMessage m = new TestMessage();
        int FLAG_A = 0x01;
        int FLAG_B = 0x02;
        assertFalse(m.isFlagSet(FLAG_A));
        m.setFlag(FLAG_A);
        assertTrue(m.isFlagSet(FLAG_A));
        // unset correctly removes the flag
        m.unsetFlag(FLAG_A);

    }

    /**
     * Test constructor with a malformed token.
     */
    @Test
    void testConstructorMalformed() {
        byte[] malformedToken = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        assertThrows(PACDecodingException.class, () -> new KerberosEncData(malformedToken, Collections.emptyMap()));
    }

    /**
     * Test constructor with an unknown field.
     *