*
     * @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;
            }

     *
     * @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();

            throw this.e;
        }
    }

    synchronized void write(final byte[] buffer, final int len, final SmbFileOutputStream d) {
        this.b = buffer;
        this.n = len;
        this.out = d;
        this.ready = false;
        notify();
    }

    @Override
    public void run() {
        synchronized (this) {
            try {
                for (;;) {

            return hashAlgorithm;
        }

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

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

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.
 */

  }

  @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();
    }

    results: MutableList<InetAddress>,
    failures: MutableList<Exception>,
  ) {
    try {
      val addresses = readResponse(hostname, response)
      synchronized(results) {
        results.addAll(addresses)
      }
    } catch (e: Exception) {
      synchronized(failures) {
        failures.add(e)
      }
    }
  }

  @Throws(UnknownHostException::class)
  private fun throwBestFailure(

    }

    /**
     * Establishes RDMA connection to the remote server.
     *
     * @throws IOException if connection fails
     */
    public void connectRdma() throws IOException {
        synchronized (connectionLock) {
            if (rdmaConnection != null && rdmaConnection.isConnected()) {
                return;
            }

            try {
                rdmaConnection =

      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(