@DisplayName("Should return salt correctly")
        void testGetSalt() {
            int[] hashAlgos = { 0x01 };
            byte[] salt = { 0x01, 0x02, 0x03, 0x04 };
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            assertArrayEquals(salt, context.getSalt());
            // The implementation returns the same reference, not a defensive copy

        assertNotNull(instance1);
        assertNotNull(instance2);
        // The second setInstance replaces the first, so they should not be the same
        assertNotSame(instance1, instance2);
        // Getting instance again should return the same as instance2
        assertSame(instance2, LogStream.getInstance());
    }

    @Test
    void testLogStreamInheritsFromPrintStream() {

    }

    /**
     * Test: Thread-safe listener invocation during connection
     * Verifies that listeners can be added while connect() is executing
     */
    @Test
    public void testConcurrentListenerInvocation() throws Exception {
        // This test verifies CopyOnWriteArrayList allows safe iteration
        assertTrue("OnConnectListener list should be thread-safe",

Execution context and configuration.

**Important Fields**:
```java
String sessionId                // Format: yyyyMMddHHmmssSSS
volatile CrawlerStatus status   // DONE, RUNNING
AtomicLong accessCount          // Thread-safe counter
int numOfThread = 10            // Crawler threads
int maxDepth = -1               // Max depth (-1 = unlimited)
long maxAccessCount = 0         // Max URLs (0 = unlimited)
```

        startLatch.countDown();

        // Wait for all threads to complete
        assertTrue("Threads did not complete in time", doneLatch.await(5, TimeUnit.SECONDS));

        // All threads should fail with the same IOException (project ID is blank)
        // But importantly, there should be no race condition errors
        assertEquals(threadCount, failureCount.get());
        assertEquals(0, successCount.get());

    }

    /**
     * Test isPathSafe with safe path
     *
     * @throws Exception
     */
    @Test
    public void testIsPathSafe_SafePath() throws Exception {
        final Path baseDir = tempFolder.getRoot().toPath();
        final Path safePath = baseDir.resolve("subdir/file.txt");

        assertTrue("Safe path should be allowed", FileUtil.isPathSafe(safePath, baseDir));
    }

    /**

        public void clearRules() {
            rules.clear();
        }

        public List<Rule> getRules() {
            return new ArrayList<>(rules);
        }
    }

    /**
     * Thread-safe implementation of RuleManager
     */
    public static class ThreadSafeRuleManager implements RuleManager {
        private final List<Rule> rules = new CopyOnWriteArrayList<>();

        @Override

    protected static final int DEFAULT_BUF_SIZE = 4096; // 4k

    /** Max Buffer Size */
    protected static final int MAX_BUF_SIZE = 10 * 1024 * 1024; // 10m

    /**
     * Validates that a given path is safe and does not attempt path traversal attacks.
     * <p>
     * This method checks if the resolved absolute path starts with the allowed base directory,

        // Simulate invalidation
        assertFalse(handle.isOpen(), "Becomes not open when underlying handle invalid");

        // After close, report stale
        handle.close();
        assertTrue(handle.isStale(), "Closed handle reports stale");
    }

    @Test
    @DisplayName("getSessionKey propagates CIFSException from session acquisition")
    void getSessionKey_exception_propagates() throws Exception {

        // Mix of same and different hosts
        for (int i = 0; i < numTasks; i++) {
            final int index = i;
            tasks.add(new Callable<Integer>() {
                public Integer call() throws Exception {
                    final UrlQueue q = new UrlQueueImpl();
                    // Use modulo to create multiple accesses to same hosts