raf.writeFloat(1.0f);
        raf.writeDouble(1.0);

        // Verify length counts - using times() to check exact counts
        verify(raf, times(2)).write(any(byte[].class), anyInt(), eq(2)); // short and char
        verify(raf, times(2)).write(any(byte[].class), anyInt(), eq(4)); // int and float
        verify(raf, times(2)).write(any(byte[].class), anyInt(), eq(8)); // long and double
    }

    @Test

        try (SamrPolicyHandle handle = new SamrPolicyHandle(mockHandle, server, access)) {
            assertNotNull(handle);
            // Verify that sendrecv was called with MsrpcSamrConnect4
            verify(mockHandle, times(1)).sendrecv(any(MsrpcSamrConnect4.class));
            verify(mockHandle, never()).sendrecv(any(MsrpcSamrConnect2.class));
        }
    }

    @Test
    void testConstructor_NullServer() throws IOException {

        // Verify constructor invoked acquire once
        verify(treeConnection, times(1)).acquire();

        // getConfig delegates
        when(treeConnection.getConfig()).thenReturn(config);
        assertSame(config, handle.getConfig());
        verify(treeConnection).getConfig();

        // isConnected delegates

        // Execute
        List<FileNotifyInformation> result = watchHandle.watch();

        // Verify
        assertNotNull(result);
        assertEquals(3, result.size());
        assertEquals(fileNotifyInfo1, result.get(0));
        assertEquals(fileNotifyInfo2, result.get(1));
        assertEquals(fileNotifyInfo3, result.get(2));
        verify(watchHandle, times(1)).watch();
    }

    /**

        jcifs.SID[] sids = { mockSid1, mockSid2 };
        LsarSidArrayX lsarSidArrayX = new LsarSidArrayX(sids);

        // Verify num_sids
        assertEquals(2, lsarSidArrayX.num_sids, "num_sids should match the array length");

        // Verify sids array and its contents
        assertNotNull(lsarSidArrayX.sids, "sids array should not be null");

            Thread.sleep(500); // to make sure queue is processed, cancellation applied

            Mockito.verify(delegate).transferInitiated(transferInitiatedEvent);
            Mockito.verify(delegate).transferStarted(transferStartedEvent);
            Mockito.verify(delegate).transferProgressed(transferProgressedEvent);
            Mockito.verify(delegate).transferSucceeded(transferSucceededEvent);
        }
    }

 */
class ResolverTypeTest {

    /**
     * Tests that all expected enum constants exist.
     */
    @Test
    void testEnumConstants() {
        // Verify that each enum constant exists and can be referenced
        assertNotNull(ResolverType.RESOLVER_WINS, "RESOLVER_WINS should not be null.");
        assertNotNull(ResolverType.RESOLVER_BCAST, "RESOLVER_BCAST should not be null.");

        final String sessionId = "session1";
        final String urlPattern = "http://example.com/.*";

        urlFilterService.addIncludeUrlFilter(sessionId, urlPattern);

        // Verify the filter is stored
        assertTrue(fesenClient.prepareSearch("fess_crawler.filter")
                .setQuery(QueryBuilders.termQuery("sessionId", sessionId))
                .setSize(0)
                .execute()

        verify(mockRequest, times(1)).getCreditCost(); // Verify method was called once
    }

    @Test
    void testSetRequestCredits() {
        // Test case for setRequestCredits method
        int credits = 5;
        mockRequest.setRequestCredits(credits);

        // Verify that setRequestCredits was called with the correct argument
        verify(mockRequest, times(1)).setRequestCredits(credits);

        // Execute
        service.updateSessionId(oldSessionId, newSessionId);

        // Verify
        verify(dataHelper).getUrlQueueList(oldSessionId);
        verify(dataHelper).addUrlQueueList(newSessionId, mockQueue);
        verify(dataHelper).removeUrlQueueList(oldSessionId);
    }

    public void test_poll() {
        // Setup
        String sessionId = "session123";