* SmbFile.resolveDfs can re-insert the dr list with
                                 * the dr that was successful so that subsequent
                                 * attempts to resolve DFS use the last successful
                                 * referral first.
                                 */
                                tmp.map = links.map;

                if (state.compareAndSet(State.HALF_OPEN, State.CLOSED)) {
                    stateChangeTime.set(System.currentTimeMillis());
                    log.info("Circuit breaker {} closed after {} successful attempts", name, successes);
                }
            }
        }
    }

    /**
     * Handle failed call
     */
    private void onFailure() {
        totalFailures.incrementAndGet();

     */
    ServiceManagerState(ImmutableCollection<Service> services) {
      this.numberOfServices = services.size();
      servicesByState.putAll(NEW, services);
    }

    /**
     * Attempts to start the timer immediately prior to the service being started via {@link
     * Service#startAsync()}.
     */
    void tryStartTiming(Service service) {
      monitor.enter();
      try {

        }
        return getPath("WEB-INF/", "conf", names);
    }

    /**
     * Gets the path to configuration files, falling back to classpath resources if not found.
     * First attempts to find the file in the configuration directory, then searches the classpath.
     *
     * @param names the path components to append to the configuration directory

     */
    public fun settings(settings: Settings): Builder =
      apply {
        this.settings_.clear()
        this.settings_.merge(settings)
      }

    /**
     * Attempts to perform a web socket upgrade on the connection.
     * This will overwrite any previously set status, body, or streamHandler.
     */
    public fun webSocketUpgrade(listener: WebSocketListener): Builder =
      apply {

     *
     * @param key The name of the method.
     * @return List list of methods
     */
    List<Method> get(String key) {
        return methodByNameMap.get(key);
    }

    /**
     * Find a method.  Attempts to find the
     * most specific applicable method using the
     * algorithm described in the JLS section
     * 15.12.2 (with the exception that it can't
     * distinguish a primitive type argument from

   * or empty headers if there were none that followed.
   *
   * If the response body was closed prematurely or failed with an error, this will be the sentinel
   * value [TRAILERS_RESPONSE_BODY_TRUNCATED]. In that case attempts to read the trailers should not
   * return the value but instead throw an exception.
   */
  private var trailers: Headers? = null

  override val isResponseComplete: Boolean
    get() = state == STATE_CLOSED

// x will be resized to the size of m and overwritten. // //go:norace func (x *Nat) montgomeryMul(a *Nat, b *Nat, m *Modulus) *Nat { n := len(m.nat.limbs) mLimbs := m.nat.limbs[:n] aLimbs := a.limbs[:n] bLimbs := b.limbs[:n] switch n { default: // Attempt to use a stack-allocated backing array. T := make([]uint, 0, preallocLimbs*2) if cap(T) < n*2 { T = make([]uint, 0, n*2) } T = T[:n*2] // This loop implements Word-by-Word Montgomery Multiplication, as // described in Algorithm 4 (Fig. 3) of "Efficient...

        Map<String, String> initParams = new HashMap<>();
        initParams.put("jcifs.smb.client.domain", "TEST_DOMAIN");
        // Don't set domainController to avoid real connection attempts
        initParams.put("jcifs.http.loadBalance", "false");
        initParams.put("jcifs.http.enableBasic", "false");

  }

  /**
   * Returns an unmodifiable view of the specified multiset. Query operations on the returned
   * multiset "read through" to the specified multiset, and attempts to modify the returned multiset
   * result in an {@link UnsupportedOperationException}.
   *
   * <p>The returned multiset will be serializable if the specified multiset is serializable.
   *