throws Throwable {
                throw exception;
              }
            });
    T wrapper = wrapperFunction.apply(proxy);
    try {
      method.invoke(wrapper, getParameterValues(method));
      fail(method + " failed to throw exception as is.");
    } catch (InvocationTargetException e) {
      if (exception != e.getCause()) {

    private int count;

    private String names = "";

    /**
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        DisposableUtil.dispose();
    }

    /**
     * @throws Exception
     */
    @Test
    public void test1() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));

        new ByteSource() {
          @Override
          public InputStream openStream() throws IOException {
            if (counter[0]++ != 0) {
              throw new IllegalStateException("More than one source open");
            }
            return new FilterInputStream(source.openStream()) {
              @Override
              public void close() throws IOException {
                super.close();
                counter[0]--;

   * @param n the number of characters to skip
   * @throws EOFException if this stream reaches the end before skipping all the characters
   * @throws IOException if an I/O error occurs
   */
  public static void skipFully(Reader reader, long n) throws IOException {
    checkNotNull(reader);
    while (n > 0) {
      long amt = reader.skip(n);
      if (amt == 0) {
        throw new EOFException();
      }
      n -= amt;
    }

   * possibility for your response.
   */
  @Throws(IOException::class)
  fun byteString() = consumeSource(BufferedSource::readByteString) { it.size }

  private inline fun <T : Any> ResponseBody.consumeSource(
    consumer: (BufferedSource) -> T,
    sizeMapper: (T) -> Int,
  ): T {
    val contentLength = contentLength()
    if (contentLength > Int.MAX_VALUE) {

            // Then
            assertNotNull(cancel);
            assertEquals(mid, cancel.getMid());
        }

        @Test
        @DisplayName("Should throw NullPointerException when config is null")
        void testNullConfigurationThrowsException() throws Exception {
            // Given
            Constructor<SmbComNtCancel> constructor = SmbComNtCancel.class.getDeclaredConstructor(Configuration.class, int.class);

        this.resolutionErrorHandler = resolutionErrorHandler;
    }

    @Override
    public Set<Artifact> resolve(MavenProject project, Collection<String> scopesToResolve, MavenSession session)
            throws ArtifactResolutionException, ArtifactNotFoundException {
        return resolve(Collections.singleton(project), scopesToResolve, session);
    }

    @Override
    public Set<Artifact> resolve(

        this.repositorySystem = repositorySystem;
    }

    @Override
    public MavenExecutionRequest populateFromToolchains(MavenExecutionRequest request, PersistedToolchains toolchains)
            throws MavenExecutionRequestPopulationException {
        if (toolchains != null) {
            Map<String, List<ToolchainModel>> groupedToolchains = new HashMap<>(2);

    }

    public List<LoadedCoreExtension> loadCoreExtensions(
            MavenExecutionRequest request, Set<String> providedArtifacts, List<CoreExtension> extensions)
            throws Exception {
        try (CloseableSession repoSession = repositorySystemSessionFactory
                .newRepositorySessionBuilder(request)

     * SMB reconnection implementation.
     *
     * @param info the handle information
     * @return true if reconnection was successful
     * @throws Exception if reconnection fails
     */
    protected boolean performReconnection(HandleInfo info) throws Exception {
        // This is a template method that should be implemented by the actual
        // SMB file implementation. For now, we'll provide a basic structure.