}

    public void test_poll_withWeightTx() {
        final String sessionId = "poll_session6";
        final List<OpenSearchUrlQueue> urlQueueList = new ArrayList<>();

        // Create items with different weights
        for (int i = 1; i <= 5; i++) {
            final OpenSearchUrlQueue urlQueue = new OpenSearchUrlQueue();
            urlQueue.setCreateTime(System.currentTimeMillis());
            urlQueue.setDepth(1);

        assertTrue(str.contains("securityInformation=0x" + Hexdump.toHexString(securityInfo, 8)));
    }

    @Test
    @DisplayName("Test constructor with different security information flags")
    void testConstructorWithDifferentSecurityFlags() {
        int fid = 0x5678;
        int securityInfo = ALL_SECURITY_INFORMATION;

            assertEquals("implementation-test.txt", impl.getFileName());
        }

        @Test
        @DisplayName("Test multiple implementations with different values")
        void testMultipleImplementations() {
            // Create multiple implementations
            FileNotifyInformation addedImpl = createImplementation(FileNotifyInformation.FILE_ACTION_ADDED, "added.txt");

        // Then
        assertEquals(0, bytesRead);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100, 200 })
    @DisplayName("Should write consistent structure at different offsets")
    void testWriteBytesAtDifferentOffsets(int offset) {
        // Given
        Configuration mockConfig = mock(Configuration.class);

        verify(info, times(1)).clear();
        assertTrue(result.isEmpty(), "List should be cleared");
    }

    // Parameterized test to exercise SMB2 with different recursive and filter values
    @ParameterizedTest(name = "SMB2 param: recursive={0}, filter={1}")
    @CsvSource({ "true, 0", "false, -1" })
    @DisplayName("watch() SMB2 parameterized branches execute without error")

        byte[] buffer = new byte[16];

        // Test edge of array
        SMBUtil.writeInt2(0xFFFF, buffer, 14);
        assertEquals(0xFFFF, SMBUtil.readInt2(buffer, 14));

        // Test different offsets
        for (int offset = 0; offset <= 8; offset++) {
            SMBUtil.writeInt4(0x12345678, buffer, offset);
            assertEquals(0x12345678, SMBUtil.readInt4(buffer, offset));
        }
    }

        assertEquals(0, result);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100 })
    @DisplayName("writeBytesWireFormat should work at different offsets")
    void testWriteBytesWireFormatAtDifferentOffsets(int offset) {
        byte[] buffer = new byte[512];

        int written = request.writeBytesWireFormat(buffer, offset);

    protected int maxDepth = 10;

    /** Separator for key-value pairs in extracted text. */
    protected String fieldSeparator = ": ";

    /** Separator between different fields in extracted text. */
    protected String lineSeparator = "\n";

    /** Whether to extract top-level fields as metadata. */
    protected boolean extractMetadata = true;

    serverCert =
      HeldCertificate
        .Builder()
        .signedBy(serverIntermediateCa)
        .serialNumber(3L)
        .commonName(server.hostName)
        .addSubjectAlternativeName("different-host.com")
        .build()
    val client = buildClient(clientCert, clientIntermediateCa.certificate)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)

    }

    @Test
    @DisplayName("Should check if can reuse")
    void testCanReuse() {
        // When same config
        assertTrue(response.canReuse(mockContext, false));

        // When different config
        Configuration otherConfig = mock(Configuration.class);
        CIFSContext otherContext = mock(CIFSContext.class);
        when(otherContext.getConfig()).thenReturn(otherConfig);