return type2;
    }

    /**
     * Helper method to create a mock context with specific LanMan compatibility level
     */
    private CIFSContext createMockContextWithLanManCompat(int level) {
        CIFSContext mockCtx = mock(CIFSContext.class);
        Configuration mockConfig = mock(Configuration.class);

    message = "moved to val",
    replaceWith = ReplaceWith(expression = "tlsVersions"),
    level = DeprecationLevel.ERROR,
  )
  fun tlsVersions(): List<TlsVersion>? = tlsVersions

  @JvmName("-deprecated_supportsTlsExtensions")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "supportsTlsExtensions"),
    level = DeprecationLevel.ERROR,
  )
  fun supportsTlsExtensions(): Boolean = supportsTlsExtensions

                } while (dr != start);

                _domains = entry;
                return _domains.map;
            }
        } catch (final IOException ioe) {
            if (LogStream.level >= 3) {
                ioe.printStackTrace(log);
            }
            if (strictView && ioe instanceof SmbAuthException) {
                throw (SmbAuthException) ioe;
            }
        }

  TLS_1_0("TLSv1"), // 1999.
  SSL_3_0("SSLv3"), // 1996.
  ;

  @JvmName("-deprecated_javaName")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "javaName"),
    level = DeprecationLevel.ERROR,
  )
  fun javaName(): String = javaName

  companion object {
    @JvmStatic
    fun forJavaName(javaName: String): TlsVersion =
      when (javaName) {
        "TLSv1.3" -> TLS_1_3

import jcifs.dcerpc.rpc;
import jcifs.smb.SmbException;

/**
 * Handle for Security Account Manager (SAM) policy operations.
 * This class represents an open handle to a SAM server and provides
 * high-level access to SAM database operations.
 */
public class SamrPolicyHandle extends rpc.policy_handle implements AutoCloseable {

    private final DcerpcHandle handle;
    private boolean opened;

    /**

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.util.concurrent;

import static java.util.logging.Level.SEVERE;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.annotations.VisibleForTesting;
import java.lang.Thread.UncaughtExceptionHandler;

    if (Build.VERSION.SDK_INT < 24) return listOf()
    return super.getHandshakeServerNames(sslSocket)
  }

  override fun log(
    message: String,
    level: Int,
    t: Throwable?,
  ) {
    if (level == WARN) {
      Log.w(Tag, message, t)
    } else {
      Log.i(Tag, message, t)
    }
  }

  /**

    ```java
    HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
    loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
    client.networkInterceptors().add(loggingInterceptor);
    ```

    **Warning:** Avoid `Level.HEADERS` and `Level.BODY` in production because
    they could leak passwords and other authentication credentials to insecure
    logs.

    if (Build.VERSION.SDK_INT == 0) {
      return Jdk9Platform.buildIfSupported()
        ?: Platform()
    }

    throw IllegalStateException("Expected Android API level 21+ but was ${Build.VERSION.SDK_INT}")
  }

  actual val isAndroid: Boolean
    get() = true

  var applicationContext: Context?
    get() = (Platform.get() as? ContextAwarePlatform)?.applicationContext

    this.initialCapacity = initialCapacity;
    return this;
  }

  @CanIgnoreReturnValue
  public MapMaker concurrencyLevel(int concurrencyLevel) {
    checkArgument(
        concurrencyLevel >= 1, "concurrency level (%s) must be at least 1", concurrencyLevel);
    // GWT technically only supports concurrencyLevel == 1, but we silently
    // ignore other positive values.
    return this;
  }