when(configWithCreds.getDefaultUsername()).thenReturn("testuser");
        when(configWithCreds.getDefaultPassword()).thenReturn("testpass");
        when(configWithCreds.getDefaultDomain()).thenReturn("TESTDOMAIN");
        when(configWithCreds.getBufferCacheSize()).thenReturn(16);
        when(configWithCreds.getMaximumBufferSize()).thenReturn(65536);

        // When

            // When & Then - the implementation throws ArrayIndexOutOfBoundsException when buffer bounds are exceeded
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                Strings.findUNITermination(bufferWithoutTermination, 0, bufferWithoutTermination.length);
            }, "Should throw ArrayIndexOutOfBoundsException when termination not found within bounds");
        }

    }

    @Test
    @DisplayName("unwrap method should return correct type when supported")
    void testUnwrapMethodContract() throws Exception {
        // Given
        when(mockAddress.unwrap(Address.class)).thenReturn(mockAddress);

        // When & Then
        Address unwrapped = mockAddress.unwrap(Address.class);

        void testConstructorWithNullContext() {
            // When
            Handler testHandler = new Handler(null);

            // Then
            assertNotNull(testHandler);
        }

        @Test
        @DisplayName("Should extend jcifs.http.Handler")
        void testInheritance() {
            // Then
            assertTrue(handler instanceof jcifs.http.Handler);

    }

    @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 {
        // Given

        lenient().when(mockConfig.getDefaultDomain()).thenReturn("TESTDOMAIN");
        lenient().when(mockConfig.isUseUnicode()).thenReturn(true);
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
        lenient().when(mockConfig.getRandom()).thenReturn(mockRandom);
        lenient().when(mockConfig.getLanManCompatibility()).thenReturn(level);

        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then
        assertDoesNotThrow(() -> {
            mockBufferCache.releaseBuffer(buffer);
        }, "releaseBuffer should handle valid buffers");
    }

    @Test
    @DisplayName("getBuffer should return buffers for use")
    void testGetBufferBasicUsage() {
        // When
        byte[] buffer1 = testCache.getBuffer();

            // When/Then: Should throw DcerpcException for invalid URLs
            assertThrows(DcerpcException.class, () -> DcerpcHandle.parseBinding(url));
        }

        @Test
        @DisplayName("Should handle binding URLs without endpoints correctly")
        void testParseBindingWithoutEndpoint() {
            // When/Then: URLs without proper endpoints should fail

    }

    @Test
    @DisplayName("Should create exception with error code and message")
    void testBasicCreation() {
        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.FILE_NOT_FOUND, "test.txt");

        // Then
        assertNotNull(exception);
        assertEquals(SmbOperationException.ErrorCode.FILE_NOT_FOUND, exception.getErrorCode());

        // When & Then - should handle gracefully
        assertThrows(Exception.class, () -> {
            response.readBytesWireFormat(buffer, offset);
        });
    }

    @Test
    @DisplayName("Should verify NotifyResponse interface implementation")
    void testNotifyResponseInterface() {
        // Then
        assertTrue(response instanceof NotifyResponse);