Crawler.Options options = new Crawler.Options();
        options.sessionId = "test-session";
        options.propertiesPath = propFile.getAbsolutePath();

        // Verify the properties path is set
        assertEquals(propFile.getAbsolutePath(), options.propertiesPath);
        assertTrue(new File(options.propertiesPath).exists());
    }

    @Test

            field.setAccessible(true);
            long actualInterval = (Long) field.get(dataIndexHelper);
            assertEquals(interval, actualInterval);
        } catch (Exception e) {
            fail("Failed to verify crawlingExecutionInterval: " + e.getMessage());
        }
    }

    @Test
    public void test_setCrawlerPriority() {
        int priority = Thread.NORM_PRIORITY; // Use normal priority for tests

        // Then
        assertNotNull(smbComTreeDisconnect);
        assertEquals(ServerMessageBlock.SMB_COM_TREE_DISCONNECT, smbComTreeDisconnect.getCommand());
        verify(mockConfig).getPid(); // Verify getPid was called
    }

    /**
     * Test writeParameterWordsWireFormat returns 0
     */
    @Test
    @DisplayName("Test writeParameterWordsWireFormat always returns 0")

      Map<Integer, Integer> model = new HashMap<>();
      putModel(model, range, 1);
      RangeMap<Integer, Integer> test = TreeRangeMap.create();
      test.put(range, 1);
      verify(model, test);
    }
  }

  public void testAllRangePairs() {
    for (Range<Integer> range1 : RANGES) {
      for (Range<Integer> range2 : RANGES) {
        Map<Integer, Integer> model = new HashMap<>();

                }

                startLatch.countDown(); // Start all threads simultaneously
                assertTrue("Concurrent registration timed out", endLatch.await(10, TimeUnit.SECONDS));

                // Verify all searchers were registered (1 initial + numThreads * searchersPerThread)
                assertEquals(numThreads * searchersPerThread, registeredCount.get());

            } finally {
                executor.shutdown();

        SmbComClose close = new SmbComClose(1, 12345L);
        assertEquals(SMB_COM_CLOSE, close.command, "command should be SMB_COM_CLOSE after construction");
    }

    /**
     * Verify that writeParameterWordsWireFormat writes the file id and the
     * unsigned time correctly.  The last write time is zero which should be
     * encoded as four 0xFF bytes by {@code writeUTime}.
     */

    @BeforeEach
    void setUp() {
        buffer = new byte[1024]; // Initialize with a reasonable size
        ndrBuffer = new NdrBuffer(buffer, 0);
    }

    @Test
    void testConstructor() {
        // Verify initial state
        assertEquals(0, ndrBuffer.start);
        assertEquals(0, ndrBuffer.index);
        assertEquals(0, ndrBuffer.length);
        assertSame(ndrBuffer, ndrBuffer.deferred);

        System.out.printf("Connection Pool Performance: %d ops in %.2f ms (%.2f ms avg per thread)%n", successCount.get(), overallTimeMs,
                avgThreadTimeMs);

        // Verify performance improvements
        assertTrue(exceptions.isEmpty(), "No exceptions should occur during concurrent access");
        assertEquals(threadCount * operationsPerThread, successCount.get());

  /**
   * Override this to verify anything after running a list of Stimuli.
   *
   * <p>For example, verify that calls to remove() actually removed the correct elements.
   *
   * @param elements the expected elements passed to the constructor, as mutated by {@code
   *     remove()}, {@code set()}, and {@code add()} calls
   */
  protected void verify(List<E> elements) {}

  /** Executes the test. */

        assertNotNull(result);

        // Verify the result contains expected components
        assertTrue(result.startsWith("SmbComDelete["));
        assertTrue(result.contains("searchAttributes=0x"));
        assertTrue(result.contains("fileName=" + TEST_FILE_NAME));

        // Get private searchAttributes field to verify the hex value
        int searchAttributes = getSearchAttributes(smbComDelete);