assertEquals("working", result);

        // Close it
        cbToClose.close();

        // Should not throw exception (close should be idempotent)
        cbToClose.close();
    }

    @Test
    public void testEnhancedMetricsTracking() throws Exception {
        SmbCircuitBreaker cbWithEnhanced = new SmbCircuitBreaker("enhanced-test");

        try {

        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

        // Verify multiple closes don't cause issues

                DialectVersion.SMB302, testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple close calls should not throw
        assertDoesNotThrow(() -> {
            closeableContext.close();
            closeableContext.close(); // Second call
            closeableContext.close(); // Third call
        });
    }

    @Test
    @DisplayName("Should maintain key isolation between instances")

        }

        @Override
        public void close() throws Exception {
            if (closed) {
                return;
            }

            try {
                resource.close();
            } finally {
                closed = true;
                manager.markClosed(resourceId);
                manager.unregisterResource(resourceId);
            }
        }
    }

            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: >

        return false;
    }

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

    /**
     * {@inheritDoc}
     *

        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() {

                            timingRatio, TIMING_TOLERANCE, timeStart, timeMiddle, timeEnd));
        } finally {
            // Clean up resources
            baseAuth.close();
            startAuth.close();
            middleAuth.close();
            endAuth.close();
        }
    }

    /**
     * Test constant-time comparison with various password lengths.
     */
    @Test

        masterPassword = "MasterPassword123!@#".toCharArray();
        storage = new SecureCredentialStorage(masterPassword.clone());
    }

    @AfterEach
    public void tearDown() throws Exception {
        if (storage != null && !storage.isDestroyed()) {
            try {
                storage.close();
            } catch (Exception e) {
                // Ignore cleanup exceptions
            }
        }

     *
     * @see jcifs.SmbPipeHandle#close()
     */
    @Override
    public synchronized void close() throws CIFSException {
        final boolean wasOpen = isOpen();
        this.open = false;
        if (this.input != null) {
            this.input.close();
            this.input = null;
        }

        if (this.output != null) {
            this.output.close();
            this.output = null;