@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

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

 * loading and storing of properties from a file. It monitors the file for changes
 * and reloads the properties if the file is updated. This class is thread-safe and
 * ensures that the properties are always up-to-date.
 *
 * <p>Key Features:
 * <ul>
 *   <li>Automatically reloads properties if the file is modified.</li>

        // Given - Use same key for both encryption and decryption in test
        // In production, client would use clientEncKey/serverDecKey and server would use serverEncKey/clientDecKey
        Smb2EncryptionContext context = new Smb2EncryptionContext(EncryptionNegotiateContext.CIPHER_AES128_GCM, DialectVersion.SMB311,
                testEncryptionKey, testEncryptionKey); // Use same key for test