}

        @Test
        @DisplayName("All RPC packet flags should have unique values")
        void testRpcPacketFlagsUniqueness() {
            // Verify that RPC packet flags are unique and follow bit pattern
            assertEquals(1, Integer.bitCount(DcerpcConstants.RPC_C_PF_BROADCAST), "RPC_C_PF_BROADCAST should be a single bit");

    void testConstructorWithConfigOnly() {
        SessionRequestPacket packet = new SessionRequestPacket(mockConfig);

        assertNotNull(packet);
        // The packet should have calledName and callingName initialized but empty
        byte[] dst = new byte[256];
        int written = packet.writeTrailerWireFormat(dst, 0);
        assertTrue(written > 0);
    }

    @Test

        }
        byte[] packet = new byte[totalLen];
        System.arraycopy(header, 0, packet, 0, header.length);
        System.arraycopy(body, 0, packet, SMB2_HEADER_LENGTH, body.length);
        if (ctxOffsetFromHeader != null && ctxBytes != null) {
            System.arraycopy(ctxBytes, 0, packet, ctxOffsetFromHeader, ctxBytes.length);
        }
        return packet;
    }

    @Test

        byte[] packet = new byte[header.length + body.length];
        System.arraycopy(header, 0, packet, 0, header.length);
        System.arraycopy(body, 0, packet, header.length, body.length);

        BaseConfiguration config = new BaseConfiguration(true);
        Smb2IoctlResponse resp = new Smb2IoctlResponse(config);

        int read = resp.decode(packet, 0);

        assertThrows(IOException.class, () -> sis.read());
    }

    @Test
    @DisplayName("Unknown packet type is handled by continuing to next packet")
    void unknownPacketTypeHandled() throws IOException {
        // According to the SocketInputStream implementation, unknown packet types
        // are handled in the switch statement's default case which continues the loop
        byte[] data = new byte[] { 1, 2 };

        int totalRead = packet.readWireFormat(bais, data, 0);

        assertEquals(14, totalRead); // 4 header + 10 trailer
        assertEquals(0x85, packet.type);
        assertEquals(10, packet.length);
    }

    @Test
    @DisplayName("writeHeaderWireFormat should write correct header")
    void testWriteHeaderWireFormat() {
        packet.type = SessionServicePacket.SESSION_REQUEST;

        packet.nameTrnId = 0x1234;
        packet.isResponse = true;
        packet.opCode = NameServicePacket.QUERY;
        packet.isAuthAnswer = true;
        packet.isTruncated = true;
        packet.isRecurDesired = true;
        packet.isRecurAvailable = true;
        packet.isBroadcast = true;
        packet.resultCode = NameServicePacket.FMT_ERR;
        packet.questionCount = 1;
        packet.answerCount = 2;

        // Arrange
        NameServicePacket packet = new NodeStatusRequest(mockConfig, mockName);

        // Assert
        assertInstanceOf(NodeStatusRequest.class, packet);
        assertEquals(NameServicePacket.NBSTAT, packet.questionType);
        assertFalse(packet.isRecurDesired);
        assertFalse(packet.isBroadcast);
    }

    @Test

    class SignatureTests {

        @Test
        @DisplayName("Should detect signed packet")
        void testIsSigned() {
            response.setFlagsForTest(ServerMessageBlock2.SMB2_FLAGS_SIGNED);

            assertTrue(response.isSigned());
        }

        @Test
        @DisplayName("Should detect unsigned packet")
        void testIsNotSigned() {
            response.setFlagsForTest(0);

 * permits per second:
 *
 * {@snippet :
 * final RateLimiter rateLimiter = RateLimiter.create(5000.0); // rate = 5000 permits per second
 * void submitPacket(byte[] packet) {
 *   rateLimiter.acquire(packet.length);
 *   networkService.send(packet);
 * }
 * }
 *
 * <p>It is important to note that the number of permits requested <i>never</i> affects the