assertTrue(ctx.isMICAvailable(), "MIC available when established + integrity");

            assertTrue(ctx.isSupported(mech1), "mech1 supported");
            assertTrue(ctx.isPreferredMech(mech1), "first supported is preferred");
            assertArrayEquals(new ASN1ObjectIdentifier[] { mech1, mech2 }, ctx.getSupportedMechs(), "supported mechs");

    if (level == WARN) {
      Log.w(Tag, message, t)
    } else {
      Log.i(Tag, message, t)
    }
  }

  companion object {
    val isSupported: Boolean = isAndroid && Build.VERSION.SDK_INT >= 29

    fun buildIfSupported(): Platform? = if (isSupported) Android10Platform() else null
  }

    }

    @ParameterizedTest
    @MethodSource("supportedMechs")
    @DisplayName("isSupported returns true for supported OIDs")
    void isSupported_supportedOids(ASN1ObjectIdentifier oid) {
        assertTrue(ctx.isSupported(oid));
        assertTrue(ctx.isPreferredMech(oid));
    }

    @Test
    @DisplayName("isSupported returns false for null/unknown OIDs")
    void isSupported_unknownOrNull() {

    void testGetSupportedMechs() {
        SpnegoContext ctx = newContext();
        ASN1ObjectIdentifier[] supported = ctx.getSupportedMechs();
        assertNotNull(supported);
        assertEquals(1, supported.length);
        assertEquals(new ASN1ObjectIdentifier("1.3.6.1.5.5.2"), supported[0]);
    }

    @Test
    @DisplayName("isSupported always returns false (prevents nesting)")
    void testIsSupportedAlwaysFalse() {

            // only use token if the optimistic mechanism is supported
            if (this.mechContext.isSupported(prefMech)) {
                inputToken = tinit.getMechanismToken();
            } else {
                ASN1ObjectIdentifier found = null;
                for (final ASN1ObjectIdentifier mech : rm) {
                    if (this.mechContext.isSupported(mech)) {
                        found = mech;

        this.gssContext.requestCredDeleg(true);
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#isSupported(org.bouncycastle.asn1.ASN1ObjectIdentifier)
     */
    @Override
    public boolean isSupported(ASN1ObjectIdentifier mechanism) {
        return KRB5_MECH_OID.equals(mechanism) || KRB5_MS_MECH_OID.equals(mechanism);
    }

    /**
     * {@inheritDoc}

    @Override
    public int getFlags() {
        return 0;
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#isSupported(org.bouncycastle.asn1.ASN1ObjectIdentifier)
     */
    @Override
    public boolean isSupported(final ASN1ObjectIdentifier mechanism) {
        return NTLMSSP_OID.equals(mechanism);
    }

    /**
     * {@inheritDoc}
     *

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val client = OkHttpClient()

    // Ensure we are compiling against the right variant
    println(AndroidPlatform.isSupported)

    val url = "https://github.com/square/okhttp".toHttpUrl()
    println(url.topPrivateDomain())

    client.newCall(Request(url)).enqueue(
      object : Callback {
        override fun onFailure(

     */
    void dispose() throws CIFSException;

    /**
     * Checks whether the specified security mechanism is supported.
     * @param mechanism the security mechanism OID to check
     * @return whether the specified mechanism is supported
     */
    boolean isSupported(ASN1ObjectIdentifier mechanism);

    /**
     * Checks whether the specified mechanism is the preferred mechanism.

            }
            final Matcher matcher = getEncodingPattern().matcher(head);
            if (matcher.find()) {
                final String enc = matcher.group(1);
                if (Charset.isSupported(enc)) {
                    return enc;
                }
            }
        } catch (final Exception e) {
            if (logger.isInfoEnabled()) {