*
 *     Runtime.getRuntime().addShutdownHook(new Thread() {
 *       public void run() {
 *         // Give the services 5 seconds to stop to ensure that we are responsive to shutdown
 *         // requests.
 *         try {
 *           manager.stopAsync().awaitStopped(5, TimeUnit.SECONDS);
 *         } catch (TimeoutException timeout) {
 *           // stopping timed out
 *         }
 *       }
 *     });

            fail("Should be locked out");
        } catch (SmbException e) {
            // Expected
        }

        // Wait for lockout to expire
        Thread.sleep(2100); // Lockout is 2 seconds in test setup

        // Should be allowed again
        assertTrue(rateLimiter.checkAttempt(username, ip), "Should be allowed after lockout expiry");
    }

    @Test

        // Default constructor
    }

    /**
     * Initializes the session manager and starts the cleanup scheduler.
     */
    @PostConstruct
    public void init() {
        // 5 minutes = 300 seconds
        cleanupTask = TimeoutManager.getInstance().addTimeoutTarget(this::cleanupExpiredSessions, 300, true);
        if (logger.isDebugEnabled()) {
            logger.debug("Initialized ChatSessionManager");
        }
    }

                        }
                    }
                } finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent ops should complete");
        executor.shutdown();

        assertEquals(threadCount * operationsPerThread, successCount.get(), "All operations should succeed");
    }

    @Test

    @Size(max = 1000)
    public String entraidAuthority;

    /** Entra ID OAuth2 reply URL. */
    @Size(max = 1000)
    public String entraidReplyUrl;

    /** Entra ID state parameter TTL in seconds. */
    @Size(max = 100)
    public String entraidStateTtl;

    /** Entra ID default groups. */
    @Size(max = 1000)
    public String entraidDefaultGroups;

    /** Entra ID default roles. */

            // Performance assertion - should complete within reasonable time
            long duration = endTime - startTime;
            assertTrue(duration < 5000, "Artifact computation should complete within 5 seconds for 100 POMs");

            // Verify correctness
            assertNotNull(gavs, "Artifact set should not be null");
            assertEquals(100, gavs.size(), "Should have computed GAVs for all 100 POMs");
        }

## Version 2.5.0

_2015-08-25_

 *  **Timeouts now default to 10 seconds.** Previously we defaulted to never
    timing out, and that was a lousy policy. If establishing a connection,
    reading the next byte from a connection, or writing the next byte to a
    connection takes more than 10 seconds to complete, you’ll need to adjust
    the timeouts manually.

        logger.info("Total time:  {}{}", formatDuration(time), wallClock);

        ZonedDateTime rounded = finish.truncatedTo(ChronoUnit.SECONDS).atZone(ZoneId.systemDefault());
        logger.info("Finished at: {}", formatTimestamp(rounded));
    }

    @Override
    public void projectSkipped(ExecutionEvent event) {
        if (logger.isInfoEnabled()) {

      " hostAddress=${route.socketAddress}" +
      " cipherSuite=${handshake?.cipherSuite ?: "none"}" +
      " protocol=$protocol}"

  companion object {
    const val IDLE_CONNECTION_HEALTHY_NS = 10_000_000_000 // 10 seconds.

    fun newTestConnection(
      taskRunner: TaskRunner,
      connectionPool: RealConnectionPool,
      route: Route,
      socket: JavaNetSocket,
      idleAtNs: Long,
    ): RealConnection {

                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await(5, TimeUnit.SECONDS);
        executor.shutdown();

        // Verify all listeners were added
        assertEquals(numThreads, fesenClient.onConnectListenerList.size());
    }

    /**