*
     * @param factory The URL stream handler factory.
     */
    public static void setURLStreamHandlerFactory(final URLStreamHandlerFactory factory) {
        synchronized (PROTOCOL_HANDLERS) {
            if (Handler.factory != null) {
                throw new IllegalStateException("URLStreamHandlerFactory already set.");
            }
            PROTOCOL_HANDLERS.clear();

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract
import okhttp3.internal.assertionsEnabled

/**
 * Marker interface for objects that use the JVM's `synchronized` mechanism and the related
 * `wait()` and `notify()` functions.
 *
 * The Lockable interface is particularly handy because it ensures we lock the right `this` when
 * there are multiple `this` objects in scope.
 */

            }
        }
    }

    protected synchronized void doDisconnect(final boolean hard) throws IOException {
        doDisconnect(hard, false);
    }

    @Override
    protected synchronized boolean doDisconnect(final boolean hard, final boolean inUse) throws IOException {

      hitCount++
    }
  }

  @Synchronized internal fun trackConditionalCacheHit() {
    hitCount++
  }

  @Synchronized fun networkCount(): Int = networkCount

  @Synchronized fun hitCount(): Int = hitCount

  @Synchronized fun requestCount(): Int = requestCount

  private inner class RealCacheRequest(

    static LogStream log = LogStream.getInstance();
    static HashMap dfsRoots = null;

    static synchronized SmbTransport getSmbTransport(final UniAddress address, final int port) {
        return getSmbTransport(address, port, LADDR, LPORT, null);
    }

    static synchronized SmbTransport getSmbTransport(final UniAddress address, final int port, final InetAddress localAddr,

  }

  @Override
  public final void addTearDown(TearDown tearDown) {
    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    List<Throwable> exceptions = new ArrayList<>();
    List<TearDown> stackCopy;
    synchronized (lock) {
      stackCopy = new ArrayList<>(stack);
      stack.clear();
    }

  }

  @Override
  public final void addTearDown(TearDown tearDown) {
    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    List<Throwable> exceptions = new ArrayList<>();
    List<TearDown> stackCopy;
    synchronized (lock) {
      stackCopy = new ArrayList<>(stack);
      stack.clear();
    }

            return hashAlgorithm;
        }

        public byte[] getCurrentHash() {
            synchronized (hashLock) {
                return currentHash.clone();
            }
        }

        public void updateHash(byte[] newHash) {
            synchronized (hashLock) {
                if (newHash != null && newHash.length == currentHash.length) {

    }

    /**
     * Adds a key-value pair to the information map.
     * Initializes the info map as a synchronized LinkedHashMap if it doesn't exist.
     *
     * @param key the parameter key to store
     * @param value the parameter value to store
     */
    public synchronized void putToInfoMap(final String key, final String value) {
        if (infoMap == null) {

     *
     * @see jcifs.DfsResolver#isTrustedDomain(jcifs.CIFSContext, java.lang.String)
     */
    @Override
    public boolean isTrustedDomain(final CIFSContext tf, String domain) throws SmbAuthException {
        synchronized (this.domainsLock) {
            final Map<String, Map<String, CacheEntry<DfsReferralDataInternal>>> domains = getTrustedDomains(tf);
            if (domains == null) {
                return false;
            }