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,

    }

    /**
     * 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) {

package okhttp3

import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLSession

class RecordingHostnameVerifier : HostnameVerifier {
  @JvmField
  val calls: MutableList<String> = mutableListOf()

  @Synchronized override fun verify(
    hostname: String,
    session: SSLSession,
  ): Boolean {
    calls.add("verify $hostname")
    return true
  }

     * @param a the authenticator to set as default
     */

    public synchronized static void setDefault(final NtlmAuthenticator a) {
        if (auth != null) {
            return;
        }
        auth = a;
    }

    /**
     * Gets the URL that is requesting authentication.

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (this) {
      if (!executed) {
        runnables = new RunnableExecutorPair(runnable, executor, runnables);
        return;
      }
    }

   */
  public static TesterRequirements getTesterRequirements(Class<?> testerClass)
      throws ConflictingRequirementsException {
    synchronized (classTesterRequirementsCache) {
      TesterRequirements requirements = classTesterRequirementsCache.get(testerClass);
      if (requirements == null) {
        requirements = buildTesterRequirements(testerClass);

     *
     * @param text the text containing URLs
     * @return the text with replaced URLs
     */
    public String replaceUrls(final String text) {
        if (cachedPathMappingList == null) {
            synchronized (this) {
                if (cachedPathMappingList == null) {
                    init();
                }
            }
        }
        String result = text;

     * Registers a CrawlerClientFactory with this creator.
     * All existing client mappings will be loaded into the new factory.
     * @param crawlerClientFactory The CrawlerClientFactory to register.
     */
    public synchronized void register(final CrawlerClientFactory crawlerClientFactory) {
        clientMap.entrySet().stream().forEach(e -> load(crawlerClientFactory, e.getKey(), e.getValue()));
        clientFactoryList.add(crawlerClientFactory);

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close(long)
     */
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {
        closeInternal(lastWriteTime, true);
    }

    /**
     * @param lastWriteTime
     * @throws SmbException
     */

    @SuppressWarnings("SynchronizeOnNonFinalField")
    public T get() {
      // A 2-field variant of Double Checked Locking.
      if (!initialized) {
        synchronized (lock) {
          if (!initialized) {
            T t = delegate.get();
            value = t;
            initialized = true;
            return t;
          }
        }
      }