throw new TransferFailedException("Unable to add checksum for unsupported algorithm " + algorithm, e);
        }
    }

    private void handleChecksumFailure(String checksumPolicy, String message, Throwable cause)
            throws ChecksumFailedException {
        if (ArtifactRepositoryPolicy.CHECKSUM_POLICY_FAIL.equals(checksumPolicy)) {
            throw new ChecksumFailedException(message, cause);

            ExceptionHandler handler = new DefaultExceptionHandler();
            Map<String, String> references = new LinkedHashMap<>();
            List<MavenProject> failedProjects = new ArrayList<>();

            for (Throwable exception : result.getExceptions()) {
                ExceptionSummary summary = handler.handleException(exception);
                logSummary(context, summary, references, "");

        } finally {
            currentThread.setContextClassLoader(originalContextClassLoader);
        }
    }

    private MavenExecutionResult addExceptionToResult(MavenExecutionResult result, Throwable e) {
        if (!result.getExceptions().contains(e)) {
            result.addException(e);
        }

        return result;
    }

    assertFreshInstanceReturned(
        ArrayList.class,
        HashMap.class,
        Appendable.class,
        StringBuilder.class,
        StringBuffer.class,
        Throwable.class,
        Exception.class);
  }

  public void testGet_io() throws IOException {
    assertEquals(-1, ArbitraryInstances.get(InputStream.class).read());

    CountDownLatch completed = new CountDownLatch(1);
    ScheduledThreadPoolExecutor delegate =
        new ScheduledThreadPoolExecutor(1) {
          @Override
          protected void afterExecute(Runnable r, Throwable t) {
            completed.countDown();
          }
        };
    ListeningScheduledExecutorService service = listeningDecorator(delegate);

      this.typeVariableImpl = typeVariableImpl;
    }

    @Override
    public @Nullable Object invoke(Object proxy, Method method, @Nullable Object @Nullable [] args)
        throws Throwable {
      String methodName = method.getName();
      Method typeVariableMethod = typeVariableMethods.get(methodName);
      if (typeVariableMethod == null) {
        if (methodName.equals("getAnnotatedBounds")

        }
        return artifactRepositoryFactory.createArtifactRepository(
                repositoryId, url, repositoryLayout, snapshots, releases);
    }

    private static String getMessage(Throwable error, String def) {
        if (error == null) {
            return def;
        }
        String msg = error.getMessage();
        if (msg != null && !msg.isEmpty()) {
            return msg;
        }

                        protected void configure() {
                            try {
                                container.lookup(Injector.class).discover(extension.getClassRealm());
                            } catch (Throwable e) {
                                // ignore
                                e.printStackTrace();
                            }
                        }
                    },

    super.tearDown();
    // TODO(cpovirk): run tests in other thread instead of messing with main thread interrupt status
    Thread.interrupted();
    LocalCache.logger.removeHandler(logHandler);
  }

  private Throwable popLoggedThrowable() {
    List<LogRecord> logRecords = logHandler.getStoredLogRecords();
    assertThat(logRecords).hasSize(1);
    LogRecord logRecord = logRecords.get(0);
    logHandler.clear();

 * your application's HTTP calls.
 *
 * All start/connect/acquire events will eventually receive a matching end/release event, either
 * successful (non-null parameters), or failed (non-null throwable). The first common parameters of
 * each event pair are used to link the event in case of concurrent or repeated events e.g.
 * `dnsStart(call, domainName)` → `dnsEnd(call, domainName, inetAddressList)`.
 *