int result = request.size();

        // Then
        assertEquals(largeSize, result);
        verify(request, times(1)).size();
    }

    @Test
    @DisplayName("Test createCancel returns cancel request")
    void testCreateCancelReturnsRequest() {
        // Given
        when(request.createCancel()).thenReturn(cancelRequest);

        // When

org.apache.lucene.search.TimeLimitingCollector#getGlobalTimerThread()
org.apache.lucene.search.TimeLimitingCollector#getGlobalCounter()

@defaultMessage Don't interrupt threads use FutureUtils#cancel(Future<T>) instead
java.util.concurrent.Future#cancel(boolean)

@defaultMessage Don't try reading from paths that are not configured in Environment, resolve from Environment instead
org.elasticsearch.core.PathUtils#get(java.lang.String, java.lang.String[])

        throw IllegalStateException(
          "Cannot stream a request body without chunked encoding or a known content length!",
        )
      }
    }

  override fun cancel() {
    carrier.cancel()
  }

  /**
   * Prepares the HTTP headers and sends them to the server.
   *
   * For streaming requests with a body, headers must be prepared **before** the output stream has

            assertFailsWith<IOException> {
              response.trailers()
            }
          assertThat(exception.message).isIn(
            "Socket closed", // HTTP/1.1
            "stream was reset: CANCEL", // HTTP/2
          )
        }
      assertThat(trailersDelay).isGreaterThan(250.milliseconds)
      assertThat(trailersDelay).isLessThan(750.milliseconds)
    }
  }

  @Test

			t.Errorf("(%d) expected to get %s, instead got %s", i, niceError(testCase.expected), niceError(code))
		}
	}
}

func TestDoesPresignedSignatureMatch(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, obj); err != nil {

    }

    /**
     * Stops the log notification timer and performs a final flush.
     */
    @PreDestroy
    public void destroy() {
        if (timeoutTask != null) {
            timeoutTask.cancel();
        }
        if (logNotificationTarget != null) {
            logNotificationTarget.flush();
        }
    }

    /**

    // Multi-channel configuration fields
    /**
     * Whether to use SMB3 multi-channel support for improved performance and redundancy
     */
    protected boolean useMultiChannel;
    /**
     * Maximum number of SMB3 channels to establish per session
     */
    protected int maxChannels;
    /**
     * Channel binding policy: -1=not set, 0=disabled, 1=preferred, 2=required

    */
    int NTLMSSP_REQUEST_TARGET = 0x00000004;

    /**
    * Specifies that communication across the authenticated channel
    * should carry a digital signature (message integrity).
    */
    int NTLMSSP_NEGOTIATE_SIGN = 0x00000010;

    /**
    * Specifies that communication across the authenticated channel
    * should be encrypted (message confidentiality).
    */
    int NTLMSSP_NEGOTIATE_SEAL = 0x00000020;

    /**

    int getMaxChannels();

    /**
     * Channel binding policy
     *
     * Property {@code jcifs.smb.client.channelBindingPolicy} (String, default "preferred")
     * Values: "disabled", "preferred", "required"
     *
     * @return channel binding policy
     */
    int getChannelBindingPolicy();

    /**
     * Load balancing strategy for multi-channel
     *

              assertThat(t).isInstanceOf(CancellationException.class);
              called = true;
            }
          }
        };
    addCallback(f, callback, directExecutor());
    f.cancel(true);
  }

  public void testThrowErrorFromGet() {
    Error error = new AssertionError("ASSERT!");
    ListenableFuture<String> f = UncheckedThrowingFuture.throwingError(error);