.header("Sec-WebSocket-Version", "13")
        .header("Sec-WebSocket-Extensions", "permessage-deflate")
        .build()
    call = RealCall(webSocketClient, request, forWebSocket = true)
    call!!.enqueue(
      object : Callback {
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          val socket =
            try {
              checkUpgradeSuccess(response)

  // via delegate()); it seems inappropriate to throw ISE on this method.
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  private void validate() {
    // Don't use checkState(), because we don't want the overhead of generating the error message
    // unless it's actually going to be used; validate() is called for all set method calls, so it
    // needs to be fast.

    }
    assertEquals(
        "multiset.size() should be the sum of the counts of all entries",
        size,
        getMultiset().size());
  }

  /** Call the {@code setCount()} method under test, and check its return value. */
  abstract void setCountCheckReturnValue(E element, int count);

  /**
   * Call the {@code setCount()} method under test, but do not check its return value. Callers

```

This behavior is consistent across all keys; each key self-documents itself with valid examples.

## Dynamic systems without restarting server

The following sub-systems are dynamic i.e., configuration parameters for each sub-systems can be changed while the server is running without any restarts.

```
api                   manage global HTTP API call specific features, such as throttling, authentication types, etc.

   * mutated by the call thread only. If is accessed by background connect threads.
   */
  private val tcpConnectsInFlight = CopyOnWriteArrayList<Plan>()

  /**
   * Results are posted here as they occur. The find job is done when either one plan completes
   * successfully or all plans fail.
   */

 *
 * Every [edit] call must be matched by a call to [Editor.commit] or [Editor.abort]. Committing is
 * atomic: a read observes the full set of values as they were before or after the commit, but never
 * a mix of values.
 *
 * Clients call [get] to read a snapshot of an entry. The read will observe the value at the time
 * that [get] was called. Updates and removals after the call do not impact ongoing reads.
 *

## Version 4.0.1

_2019-07-10_

 *  Fix: Tolerate null-hostile lists in public API. Lists created with `List.of(...)` don't like it
    when you call `contains(null)` on them!
 *  Fix: Retain binary-compatibility in `okhttp3.internal.HttpHeaders.hasBody()`. Some unscrupulous
    coders call this and we don't want their users to suffer.


## Version 4.0.0

_2019-06-26_

	bucketLoader BucketMetricsLoaderFn

	// Cache for all metrics groups. Set via `.SetCache` method.
	cache *metricsCache

	// managed values follow:

	// map of metric descriptors by metric name.
	descriptorMap map[MetricName]MetricDescriptor

	// For bucket metrics, the list of buckets is stored here. It is used in the
	// Collect() call. This is protected by the `bucketsLock`.
	bucketsLock sync.Mutex

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

// Options for readDir function call
type readDirOpts struct {
	// The maximum number of entries to return
	count int
	// Follow directory symlink
	followDirSymlink bool
}

// Return all the entries at the directory dirPath.
func readDir(dirPath string) (entries []string, err error) {

            return loadCallback.call();
        }

        public void setLoadCallback(LoadCallback callback) {
            this.loadCallback = callback;
        }

        public int getLoadCallCount() {
            return loadCallCount.get();
        }
    }

    @FunctionalInterface
    interface LoadCallback {
        int call();
    }