}

    @Test
    @DisplayName("Test initial state is CLOSED")
    void testInitialState() {
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());
        assertTrue(circuitBreaker.allowsRequests());
    }

    @Test
    @DisplayName("Test successful calls in CLOSED state")
    void testSuccessfulCalls() throws Exception {

        assertNotNull(auth.getPasswordAsCharArray());
        assertFalse(auth.isClosed());

        // Close the authenticator
        auth.close();

        // Verify it's closed
        assertTrue(auth.isClosed());
        // Cannot check password after closing as it now throws IllegalStateException
        // This is actually good security practice - closed authenticators cannot be accessed

            if (!holder.closed && !holder.isAlive()) {
                // Resource object has been garbage collected but not closed
                reportLeak(holder);
                activeResources.remove(entry.getKey());
                cleaned++;
            } else if (!holder.closed && holder.getAge() > maxResourceAge * 2) {
                // Very old unclosed resource - attempt to close it

        // Need successThreshold (2) consecutive successes to close the circuit
        // Second success should close the circuit (threshold is 2)
        result = circuitBreaker.executeWithCircuitBreaker(() -> "success 1");
        assertEquals("success 1", result, "Should execute second success");
        assertEquals(State.CLOSED, circuitBreaker.getState(), "Circuit should be CLOSED after success threshold");

            It will be closed in 14 days if no further activity occurs.
            If you don't want the stale bot to close it, then set a milestone for it.
          days-before-pr-close: 14
          close-pr-message: >

                log.info("[{}] Circuit breaker closing after {} successful attempts", name, successes);
                transitionTo(State.CLOSED);
            }
        } else if (currentState == State.CLOSED) {
            // Reset failure count on success in closed state
            failureCount.set(0);
        }

        // Notify listeners
        for (CircuitBreakerListener listener : listeners) {

 * Features:
 * - Simple state management (CLOSED, OPEN, HALF_OPEN)
 * - Lock-free atomic operations
 * - Configurable thresholds and timeouts
 * - No complex dependencies
 */
public class SimpleCircuitBreaker {

    private static final Logger log = LoggerFactory.getLogger(SimpleCircuitBreaker.class);

    /**
     * Circuit breaker states
     */
    public enum State {
        CLOSED, // Normal operation

        private final AtomicBoolean closed = new AtomicBoolean(false);
        private final String name;

        TestResource(String name) {
            this.name = name;
        }

        @Override
        public void close() {
            closed.set(true);
        }

        boolean isClosed() {
            return closed.get();
        }

        String getName() {

                this.signingKey = null;
            }
            this.closed = true;
        } finally {
            this.signingLock.unlock();
        }
    }

    /**
     * Close the signing digest and securely wipe keys
     */
    @Override
    public void close() {
        secureWipeKey();
    }

        return false;
    }

    /**
     * {@inheritDoc}
     *
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override
    public boolean close() throws CIFSException {
        if (!this.closed) {
            Runtime.getRuntime().removeShutdownHook(this);
        }
        return false;
    }

    /**
     * {@inheritDoc}
     *