*/
    SHARE_MOVE(3),

    /**
     * IP address changed - network configuration change
     */
    IP_CHANGE(4),

    /**
     * Share deleted - share removal notification
     */
    SHARE_DELETE(5),

    /**
     * Cluster node unavailable - node down event
     */
    NODE_UNAVAILABLE(6),

    /**
     * Cluster node available - node up event
     */

        // Test forward slash normalization
        assertEquals("\\share\\folder", validator.validatePath("/share/folder"));

        // Test duplicate slash removal
        assertEquals("\\share\\folder", validator.validatePath("\\\\share\\\\folder"));

        // Test trailing slash removal
        assertEquals("\\share\\folder", validator.validatePath("\\share\\folder\\"));
    }

    @Test

        return fessConfig.getCrawlerDocumentMaxSymbolTermSizeAsInteger();
    }

    /**
     * Checks if duplicate term removal is enabled in configuration.
     *
     * @return true if duplicate terms should be removed, false otherwise
     */
    protected boolean isDuplicateTermRemoved() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        // Remove the child
        entry.removeChild(childName);
        assertFalse(entry.hasChild(childName));
        assertTrue(entry.hasChanges());

        // Remove non-existent child - should not change state
        entry.removeChild("nonexistent.txt");
        assertTrue(entry.hasChanges()); // Still has changes from previous removal
    }

    @Test

            return this;
        }

        /**
         * Sets the flag indicating whether duplicate terms should be removed.
         *
         * @param duplicateTermRemoved true if duplicate terms should be removed, false otherwise
         * @return the current instance of {@link TextNormalizeContext}
         */

        // Test normal string without control characters
        assertEquals("test", InputValidator.sanitizeForLogging("test"));

        // Test removal of control characters (they are removed, not replaced with spaces)
        assertEquals("teststring", InputValidator.sanitizeForLogging("test\0string"));
        assertEquals("teststring", InputValidator.sanitizeForLogging("test\nstring"));

        // Add at index
        ruleManager.addRule(1, rule3);
        assertEquals(3, ruleManager.getRuleCount());

        // Remove rule
        assertTrue(ruleManager.removeRule(rule2));
        assertEquals(2, ruleManager.getRuleCount());

        // Get rule after removal
        matched = ruleManager.getRule(responseData);
        assertNull(matched); // No matching rule now

        // Add rule4 which matches

        AvPairs.remove(pairs, AvPair.MsvAvFlags);

        assertEquals(1, pairs.size(), "Should have 1 pair after removal");
        assertFalse(AvPairs.contains(pairs, AvPair.MsvAvFlags), "Should not contain MsvAvFlags");
        assertTrue(AvPairs.contains(pairs, AvPair.MsvAvTimestamp), "Should still contain MsvAvTimestamp");
    }

    /**
     * Test remove method with non-existing type
     */

            }
        }

        if (!unhealthy.isEmpty()) {
            log.info("Removed {} unhealthy connections from pool", unhealthy.size());
        }

        // Perform maintenance tasks
        performMaintenanceTasks();
    }

    /**
     * Remove idle connections to free up pool space
     */
    private void removeIdleConnections() {

        @Test
        @DisplayName("Should handle concurrent remove operations")
        void testConcurrentRemoveOperations() throws InterruptedException {
            // Given
            SmbTransport transport2 = mock(SmbTransport.class);
            doNothing().when(transportPool).removeTransport(any());

            // When - simulate concurrent removes