}

    /**
     * Removes whitespace from the left side of the string.
     *
     * @param text
     *            The text to trim
     * @return The resulting string
     */
    public static final String ltrim(final String text) {
        return ltrim(text, null);
    }

    /**
     * Removes the specified characters from the left side of the string.
     *

    }

    @Test
    @DisplayName("EmptyIterator should handle remove operations multiple times")
    void testMultipleRemoveOperations() {
        // When & Then
        assertDoesNotThrow(() -> {
            emptyIterator.remove();
            emptyIterator.remove();
            emptyIterator.remove();
        }, "Multiple remove operations should not cause issues");

                } else {
                    // Remove failed handle
                    handles.remove(path);
                    guidToHandle.remove(info.getCreateGuid());
                    removePersistedHandle(info);
                    log.warn("Reconnection failed, removed handle for: {}", path);
                }
            }
        } finally {

     * @param rule the rule to be added
     */
    void addRule(int index, Rule rule);

    /**
     * Removes the specified rule from the rule manager.
     *
     * @param rule the rule to be removed
     * @return true if the rule was successfully removed, false otherwise
     */
    boolean removeRule(Rule rule);

    /**
     * Checks if the specified rule exists.
     *

        }
    }

    /**
     * Removes a scheduled job completely from the job manager.
     *
     * @param scheduledJob the scheduled job to remove
     * @throws ScheduledJobException if the job cannot be removed
     */
    public void remove(final ScheduledJob scheduledJob) {
        try {

    /**
     * Simulate a witness unregistration
     *
     * @param registrationId the registration ID to remove
     * @return true if registration was found and removed
     */
    public boolean unregisterWitness(String registrationId) {
        MockRegistration removed = registrations.remove(registrationId);
        if (removed != null) {
            log.debug("Mock unregistered witness: {}", registrationId);
            return true;

        return null;
    }

    /**
     * Remove and securely wipe a session key
     *
     * @param sessionId unique session identifier
     */
    public void removeSessionKey(String sessionId) {
        checkNotClosed();

        // Remove from memory maps
        SecretKey secretKey = sessionKeys.remove(sessionId);
        byte[] rawKey = rawKeys.remove(sessionId);

        // Wipe the raw key bytes

        // Remove main key
        keyManager.removeSessionKey(sessionId);

        // Verify main key is removed (archives stay)
        assertFalse(keyManager.hasSessionKey(sessionId), "Main key should be removed");
        // Note: Archives are not automatically removed when removing main key
    }

        }
    }

    /**
     * Removes all channels for a session.
     *
     * @param sessionId the session identifier
     */
    public void removeChannels(String sessionId) {
        ChannelGroup channelGroup = sessionChannels.remove(sessionId);
        if (channelGroup != null) {
            for (ChannelInfo channel : channelGroup.getChannels()) {

        public boolean addAll(final int index, final Collection<? extends E> c) {
            return parent.addAll(index, c);
        }

        @Override
        public boolean removeAll(final Collection<?> c) {
            return parent.removeAll(c);
        }

        @Override
        public boolean retainAll(final Collection<?> c) {
            return parent.retainAll(c);
        }

        @Override