throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a multiset that may contain a non-{@code
   * Comparable} element.</b> Proper calls will resolve to the version in {@code
   * ImmutableSortedMultiset}, not this dummy version.
   *
   * @throws UnsupportedOperationException always
   * @deprecated <b>Pass a parameter of type {@code Comparable} to use {@link

        }

        @Test
        @DisplayName("Should handle repeated size calls efficiently")
        void testRepeatedSizeCalls() {
            TestCreateContextRequest request = new TestCreateContextRequest("SIZE_TEST".getBytes(StandardCharsets.UTF_8));

            int expectedSize = request.size();

            // Call size multiple times
            for (int i = 0; i < 1000; i++) {

        when(tree.acquire()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(true); // simplifies stream init
        when(tree.getReceiveBufferSize()).thenReturn(4096);

        // Act: first calls construct streams, second calls return cached
        SmbPipeInputStream in1 = handle.getInput();
        SmbPipeInputStream in2 = handle.getInput();
        SmbPipeOutputStream out1 = handle.getOutput();

	drwMutexRefreshCallTimeout = 5 * time.Second

	// dRWMutexUnlockTimeout - default timeout for the unlock call
	drwMutexUnlockCallTimeout = 30 * time.Second

	// dRWMutexForceUnlockTimeout - default timeout for the unlock call
	drwMutexForceUnlockCallTimeout = 30 * time.Second

	// dRWMutexRefreshInterval - default the interval between two refresh calls
	drwMutexRefreshInterval = 10 * time.Second

	// Use a separate client to avoid recursive calls.
	healthClient := rest.NewClient(serverURL, globalInternodeTransport, newCachedAuthToken())
	healthClient.NoMetrics = true

	// Construct a new health function.
	restClient.HealthCheckFn = func() bool {
		ctx, cancel := context.WithTimeout(context.Background(), restClient.HealthCheckTimeout)
		defer cancel()
		respBody, err := healthClient.Call(ctx, peerRESTMethodHealth, nil, nil, -1)

    throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a set that may contain a non-{@code Comparable}
   * element.</b> Proper calls will resolve to the version in {@code ImmutableSortedSet}, not this
   * dummy version.
   *
   * @throws UnsupportedOperationException always
   * @deprecated <b>Pass a parameter of type {@code Comparable} to use {@link

        URLStreamHandlerFactory mockFactory2 = mock(URLStreamHandlerFactory.class);

        Handler.setURLStreamHandlerFactory(mockFactory1); // First call, should succeed.

        assertThrows(IllegalStateException.class, () -> {
            Handler.setURLStreamHandlerFactory(mockFactory2); // Second call, should fail.
        }, "Setting the factory a second time should throw IllegalStateException.");
    }

    @Test

        .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)

     * blocking on the load. Multiple concurrent calls to {@link Cache} lookup methods with the same
     * key on an absent value should result in a single call to either {@code recordLoadSuccess} or
     * {@code recordLoadException} and multiple calls to this method, despite all being served by
     * the results of a single load operation.
     *

 * <p>This class is GWT-compatible.
 *
 * <h3>Purpose</h3>
 *
 * <p>The main purpose of {@code ListenableFuture} is to help you chain together a graph of
 * asynchronous operations. You can chain them together manually with calls to methods like {@link
 * Futures#transform(ListenableFuture, com.google.common.base.Function, Executor) Futures.transform}
 * (or {@link FluentFuture#transform(com.google.common.base.Function, Executor)