webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ): Unit = throw e
      },
    )
    newWebSocket()
    assertThat(testLogHandler.take()).isEqualTo("INFO: [WS client] onFailure")
  }

  @Test
  fun throwingOnMessageClosesImmediatelyAndFails() {
    webServer.enqueue(
      MockResponse
        .Builder()

   * value, you should always choose it explicitly.
   *
   * <p>The current implementation uses the concurrency level to create a fixed number of hashtable
   * segments, each governed by its own write lock. The segment lock is taken once for each explicit
   * write, and twice for each cache loading computation (once prior to loading the new value, and
   * once after loading completes). Much internal cache management is performed at the segment

     */
    public void setShareAccess(final int shareAccess) {
        this.shareAccess = shareAccess;
    }

    /**
     * Set the create disposition specifying what action to take if file exists or doesn't exist
     * @param createDisposition the createDisposition to set
     */
    public void setCreateDisposition(final int createDisposition) {
        this.createDisposition = createDisposition;

   *
   * ```
   *   pinnedRoot (trusted by CertificatePinner)
   *     -> pinnedIntermediate (trusted by CertificatePinner)
   *       -> realVictim
   * ```
   *
   * The attacker compromises a CA. They take the public key from an intermediate certificate
   * signed by the compromised CA's certificate and uses it in a non-CA certificate. They ask the
   * pinned CA above to sign it for non-certificate-authority uses:
   *

    if (reference == null) {
      throw new VerifyException(lenientFormat(errorMessageTemplate, errorMessageArgs));
    }
    return reference;
  }

  // TODO(kevinb): consider <T> T verifySingleton(Iterable<T>) to take over for
  // Iterables.getOnlyElement()

  private Verify() {}

	// Route directly to output.
	m.respWait = out
}

// RequestStream will send a single payload request and stream back results.
// 'requests' can be nil, in which case only req is sent as input.
// It will however take less resources.
func (m *muxClient) RequestStream(h HandlerID, payload []byte, requests chan []byte, responses chan Response) (*Stream, error) {
	if m.init {
		return nil, errors.New("mux client already used")
	}

     *            The Type-2 message which this represents a response to.
     * @param targetName
     *            SPN of the target system, optional
     * @param passwordHash
     *            The NT password hash, takes precedence over password (which is no longer required unless legacy LM
     *            authentication is needed)
     * @param password
     *            The password to use when constructing the response.

	if took > maxDurationSecondsForLog {
		// Log if we took a lot of time to load.
		logger.Info("IAM expired STS purge took %.2fs", took)
	}

	// Store the newly populated map in the iam cache. This takes care of
	// removing stale entries from the existing map.
	cache.iamSTSAccountsMap = stsAccountsFromStore

	stsAccPoliciesFromStore.Range(func(k string, v MappedPolicy) bool {
		cache.iamSTSPolicyMap.Store(k, v)

Also note that `mc` version `RELEASE.2021-09-02T09-21-27Z` or older supports only a single remote target per bucket. To take advantage of multiple destination replication, use the latest version of `mc`

		if errs[index] != nil {
			parities[index] = -1
			continue
		}
		if !metadata.IsValid() {
			parities[index] = -1
			continue
		}
		//nolint:gocritic
		// Delete marker or zero byte objects take highest parity.
		if metadata.Deleted || metadata.Size == 0 {
			parities[index] = totalShards / 2
		} else if metadata.TransitionStatus == lifecycle.TransitionComplete {