class RecordingHostnameVerifier : HostnameVerifier {
  @JvmField
  val calls: MutableList<String> = mutableListOf()

  @Synchronized override fun verify(
    hostname: String,
    session: SSLSession,
  ): Boolean {
    calls.add("verify $hostname")
    return true
  }

    list.add(new MockRunnable(countDownLatch), exec);
    list.add(new MockRunnable(countDownLatch), exec);
    assertEquals(3L, countDownLatch.getCount());

    list.execute();

    // Verify that all of the runnables execute in a reasonable amount of time.
    assertTrue(countDownLatch.await(1L, SECONDS));
  }

  public void testExecute_idempotent() {
    AtomicInteger runCalled = new AtomicInteger();

        run: uv pip install -r requirements-docs-insiders.txt
        env:
          TOKEN: ${{ secrets.FASTAPI_MKDOCS_MATERIAL_INSIDERS }}
      - name: Verify Docs
        run: python ./scripts/docs.py verify-docs
      - name: Export Language Codes
        id: show-langs
        run: |
          echo "langs=$(python ./scripts/docs.py langs-json)" >> $GITHUB_OUTPUT

  build-docs:
    needs:

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

    void testPasswordStoredAsCharArray() throws Exception {
        authenticator = new NtlmPasswordAuthenticator("DOMAIN", "username", "password123");

        // Use reflection to verify password is stored as char[]
        Field passwordField = NtlmPasswordAuthenticator.class.getDeclaredField("password");
        passwordField.setAccessible(true);
        Object passwordValue = passwordField.get(authenticator);

        bb.put(node.getBytes(StandardCharsets.UTF_16LE));
        bb.putShort((short) 0);

        // Decode
        int decodedSize = referral.decode(testBuffer, 0, testBuffer.length);

        // Verify
        assertEquals(100, decodedSize);
        assertEquals(3, referral.getVersion());
        assertEquals(100, referral.getSize());
        assertEquals(1, referral.getServerType());

        assertFalse(ipc.shouldForceSigning());

        // Verify interactions sequence for one call
        InOrder inOrder = inOrder(config, creds);
        ipc = locator("smb://server/IPC$/");
        ipc.shouldForceSigning();
        inOrder.verify(config, atLeastOnce()).isIpcSigningEnforced();
        inOrder.verify(creds, atLeastOnce()).isAnonymous();
    }

    @Test

    public void test_register() {
        testScriptEngine.register();

        // Verify that the engine was registered with the factory
        ScriptEngine retrievedEngine = scriptEngineFactory.getScriptEngine("testEngine");
        assertNotNull(retrievedEngine);
        assertEquals(testScriptEngine, retrievedEngine);

        // Verify that the engine was also registered with its class name

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

class DefaultToolchainTest {
    private final Logger logger = mock(Logger.class);

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
    }