* <p>
     * The {@link Traverser} returned by this method uses the path where the specified class can be referenced by its FQN as the root.
     * For example, if the specified class is <code>foo.Bar</code> and its class file is located at <code>classes/foo/Bar.class</code>,
     * the {@link Traverser} returned by this method will handle the collection of resources under the <code>classes</code> directory.
     * </p>
     *
     * @param referenceClass

		// Previously, this value was set right before a response was sent to
		// the client. So, logger and Error response XML were not using this
		// value. This is set here so that this header can be logged as
		// part of the log entry, Error response XML and auditing.
		// Set custom headers such as x-amz-request-id for each request.
		w.Header().Set(xhttp.AmzRequestID, mustGetRequestID(UTCNow()))

    assertThat(firstFrame(logs, "HEADERS")!!, "header logged")
      .contains("HEADERS       END_HEADERS")
    // While MockWebServer waits to read the client's HEADERS frame before sending the response, it
    // doesn't wait to read the client's DATA frame and may send a DATA frame before the client
    // does. So we can't assume the client's empty DATA will be logged first.

    server.send("Hello, WebSockets!")
    clientListener.assertTextMessage("Hello, WebSockets!")
    closeWebSockets(webSocket, server)
  }

  /**
   * We had a bug where web socket connections were leaked if the HTTP connection upgrade was not
   * successful. This test confirms that connections are released back to the connection pool!
   * https://github.com/square/okhttp/issues/4258
   */
  @Test

    if (network) {
      builder.addNetworkInterceptor(interceptor)
    } else {
      builder.addInterceptor(interceptor)
    }
    client = builder.build()
  }

  /** Catches exceptions that are otherwise headed for the uncaught exception handler.  */
  private class ExceptionCatchingExecutor : ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS, SynchronousQueue()) {
    private val exceptions: BlockingQueue<Exception> = LinkedBlockingQueue()

that after redirection the browser may land on a different MinIO server. For example, the domain `console.minio.example.org` may resolve to `console-X.minio.example.org`, where `X` is `1`, `2`, `3` or `4`. For the login to work, if the user first landed on `console-1.minio.example.org`, they must be redirected back to the same place after logging in at the OpenID provider's web-page. To ensure this, set the `MINIO_IDENTITY_OPENID_REDIRECT_URI_DYNAMIC=on` parameter - this lets MinIO set the redirect...

             */
            if (this.state != 5 && this.state != 6) {
                doConnect();
            }
        } catch (final Exception ex) {
            ex0 = ex; // Defer to below where we're locked
            return;
        } finally {
            synchronized (run_thread) {
                if (run_thread != this.thread) {
                    /*

	LDADDALH	R5, (RSP), R7                // e703e578
	LDADDALB	R5, (R6), R7                 // c700e538
	LDADDALB	R5, (RSP), R7                // e703e538
	LDADDD	R5, (R6), R7                         // c70025f8
	LDADDD	R5, (RSP), R7                        // e70325f8
	LDADDW	R5, (R6), R7                         // c70025b8
	LDADDW	R5, (RSP), R7                        // e70325b8

}

// load the cache content with name from minioMetaBackgroundOpsBucket.
// Only backend errors are returned as errors.
// The loader is optimistic and has no locking, but tries 5 times before giving up.
// If the object is not found, a nil error with empty data usage cache is returned.
func (d *dataUsageCache) load(ctx context.Context, store objectIO, name string) error {

    /** The key of the message: Uploaded a synonym file. */
    public static final String SUCCESS_upload_synonym_file = "{success.upload_synonym_file}";

    /** The key of the message: Uploaded a protwords file. */
    public static final String SUCCESS_upload_protwords_file = "{success.upload_protwords_file}";

    /** The key of the message: Uploaded a stopwords file. */