}

    @Test
    @DisplayName("Should create correct response")
    void testCreateResponse() {
        // When
        Smb2ChangeNotifyResponse response = request.createResponse(mockContext, request);

        // Then
        assertNotNull(response);
        assertTrue(response instanceof Smb2ChangeNotifyResponse);
    }

    @Test
    @DisplayName("Should calculate correct size")
    void testSize() {

    class ConstructorTests {

        @Test
        @DisplayName("Should throw DcerpcException for invalid URL format")
        void testConstructor_InvalidUrl() {
            String invalidUrl = "invalid:server";
            assertThrows(DcerpcException.class, () -> new DcerpcPipeHandle(invalidUrl, mockContext, false),
                    "Should throw DcerpcException for invalid protocol");
        }

        @Test

        assertTrue(config.isUseMultiChannel(), "Multi-channel should be enabled by default");
        assertEquals(4, config.getMaxChannels(), "Default max channels should be 4");
        assertEquals(1, config.getChannelBindingPolicy(), "Default binding policy should be preferred");
        assertEquals("adaptive", config.getLoadBalancingStrategy(), "Default strategy should be adaptive");

    class WireFormatTests {

        @Test
        @DisplayName("Should read parameters wire format")
        void testReadParametersWireFormat() {
            byte[] buffer = new byte[10];
            int result = response.readParametersWireFormat(buffer, 0, 2);
            assertEquals(2, result);
        }

        @Test
        @DisplayName("Should write setup wire format")
        void testWriteSetupWireFormat() {

        assertTrue(response.isValidTid());
    }

    @Test
    @DisplayName("Should return null for getService")
    void testGetService() {
        // When
        String service = response.getService();

        // Then
        assertNull(service);
    }

    @Test
    @DisplayName("Should prepare next request correctly when received")
    void testPrepareWhenReceived() throws Exception {

        assertNotNull(provider, "Auto provider selection should return a provider");
        assertTrue(provider.isAvailable(), "Returned provider should be available");
    }

    @Test
    public void testCreateProviderTcp() {
        RdmaProvider provider = RdmaProviderFactory.createProvider("tcp");
        assertNotNull(provider, "TCP provider should always be available");

    }

    @Test
    @DisplayName("Should preserve stack trace")
    void testStackTracePreservation() {
        // When
        RuntimeCIFSException exception = new RuntimeCIFSException("Test exception");

        // Then
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Should contain this test method in stack trace

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with zero offset and length")
        void testConstructorWithZeroValues() {
            lock = new Smb2Lock(0L, 0L, 0);

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with maximum values")
        void testConstructorWithMaxValues() {

    }

    @Test
    @DisplayName("Should create Type 1 message with default flags")
    void testType1MessageCreation() {
        // When
        Type1Message type1 = new Type1Message(mockContext);

        // Then
        assertNotNull(type1);
        // Note: getType() method does not exist in Type1Message
        assertTrue(type1.getFlags() != 0); // Should have some flags set
    }

    @Test

    @Test
    @DisplayName("Should create SpnegoException with default constructor")
    void testDefaultConstructor() {
        // When
        SpnegoException ex = new SpnegoException();

        // Then
        assertNotNull(ex, "Exception should be created");
        assertNull(ex.getMessage(), "Default message should be null");
        assertNull(ex.getCause(), "Default cause should be null");