/** Cache for storing group information to reduce API calls. */
    protected Cache<String, Pair<String[], String[]>> groupCache;

    /** Group cache expiry time in seconds. */
    protected long groupCacheExpiry = 10 * 60L;

    /** Use V2 endpoint. */
    protected boolean useV2Endpoint = true;

    /**
     * Initializes the Azure AD authenticator.

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

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

      " 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 {

    assertThat(Adapters.parseGeneralizedTime("19920622123421Z"))
      .isEqualTo(date("1992-06-22T12:34:21.000+0000").time)
  }

  @Disabled("fractional seconds are not implemented")
  @Test
  fun `parse generalized time with fractional seconds`() {
    assertThat(Adapters.parseGeneralizedTime("19920722132100.3Z"))
      .isEqualTo(date("1992-07-22T13:21:00.300+0000").time)
  }

 * efficient `max-age=0` directive instead:
 *
 * ```java
 * Request request = new Request.Builder()
 *     .cacheControl(new CacheControl.Builder()
 *         .maxAge(0, TimeUnit.SECONDS)
 *         .build())
 *     .url("http://publicobject.com/helloworld.txt")
 *     .build();
 * ```
 *
 * ## Force a Cache Response
 *

    /** Logger instance for this class. */
    private static final Logger logger = LogManager.getLogger(PdfExtractor.class);

    /** Timeout for PDF extraction in milliseconds (default: 30 seconds). */
    protected long timeout = 30000; // 30sec

    /** Whether the extraction thread should be a daemon thread. */
    protected boolean isDaemonThread = false;

    /**
     * Creates a new PdfExtractor instance.

        names = testFactory.getDataStoreNames();
        assertEquals(2, names.length);
        assertEquals(1, loadCount[0]); // Should not increment

        // Simulate time passing (more than 60 seconds)
        testFactory.lastLoadedTime = System.currentTimeMillis() - 61000L;

        // Should reload after cache expiry
        names = testFactory.getDataStoreNames();
        assertEquals(2, names.length);

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

              <sourceLevel>1.8</sourceLevel>
              <!-- Keep these timeouts very large because, if we hit the timeout, the tests silently pass :( -->
              <testTimeOut>86400 <!-- seconds --></testTimeOut>
              <testMethodTimeout>1440 <!-- minutes --></testMethodTimeout>
              <!-- Presumably we want watchFileChanges=false here, since we want it for compile: -->

            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