/**
     * Helper method to set defaultSettings on an authenticator instance
     */
    private void setDefaultSettings(SamlAuthenticator authenticator, Map<String, Object> settings) throws Exception {
        Field defaultSettingsField = SamlAuthenticator.class.getDeclaredField("defaultSettings");
        defaultSettingsField.setAccessible(true);
        defaultSettingsField.set(authenticator, settings);
    }

    @Test

        ssoManager.register(authenticator3);

        SsoAuthenticator[] authenticators = ssoManager.getAuthenticators();
        assertEquals(3, authenticators.length);
        assertEquals(authenticator1, authenticators[0]);
        assertEquals(authenticator2, authenticators[1]);
        assertEquals(authenticator3, authenticators[2]);
    }

    @Test
    public void test_getAuthenticators_withNoRegisteredAuthenticators() {

    }

    object AuthenticatorOverride : Override<Authenticator> {
      override fun Interceptor.Chain.value(): Authenticator = authenticator

      override fun Interceptor.Chain.withOverride(value: Authenticator): Interceptor.Chain = withAuthenticator(value)

      override fun OkHttpClient.Builder.withOverride(value: Authenticator): OkHttpClient.Builder = authenticator(value)

    return copy(retryOnConnectionFailure = retryOnConnectionFailure)
  }

  override fun withAuthenticator(authenticator: Authenticator): Interceptor.Chain {
    check(exchange == null) { "authenticator can't be adjusted in a network interceptor" }

    return copy(authenticator = authenticator)
  }

  override fun withCookieJar(cookieJar: CookieJar): Interceptor.Chain {

    }

    /**
     * Test that closed authenticator prevents all sensitive operations
     */
    @Test
    @DisplayName("Test closed authenticator blocks all sensitive operations")
    public void testClosedAuthenticatorBlocking() throws Exception {
        NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("DOMAIN", "user", "BlockedPass123!");

        // Close the authenticator
        auth.close();

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.spnego.NegTokenInit;

/**
 * Base kerberos authenticator
 *
 * Uses a subject that contains kerberos credentials for use in GSSAPI context establishment.
 *
 * Be advised that short/NetBIOS name usage is not supported with this authenticator. Always specify full FQDNs.

        // Execute
        authenticator.resolveCredential(resolver);

        // Verify
        assertTrue(authenticator.isResolverCalled());
        assertNotNull(authenticator.getLastResolver());
    }

    @Test
    public void test_resolveCredential_withNullResolver() {
        // Execute
        authenticator.resolveCredential(null);

        // Verify

    val hostnameVerifier: HostnameVerifier = client.hostnameVerifier()
    val certificatePinner: CertificatePinner = client.certificatePinner()
    val proxyAuthenticator: Authenticator = client.proxyAuthenticator()
    val authenticator: Authenticator = client.authenticator()
    val connectionPool: ConnectionPool = client.connectionPool()
    val dns: Dns = client.dns()
    val followSslRedirects: Boolean = client.followSslRedirects()

        return result == 1;
    }

    /** The authentication type */
    private AuthenticationType type;
    /** The authentication domain */
    private String domain;
    /** The username for authentication */
    private String username;
    /** The password for authentication */
    private char[] password;
    /** The client challenge for NTLM authentication */
    private byte[] clientChallenge = null;

        auth.refresh();
        Subject afterRefresh = auth.getSubject();
        // After refresh, may succeed or fail depending on JAAS configuration
        // Just verify that refresh doesn't break the authenticator
        assertNotNull(auth, "Authenticator should remain usable after refresh");
    }

    @Test
    @DisplayName("handle: sets NameCallback and PasswordCallback on happy path")