*/
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      Assert.assertEquals(expectedData, future.get());
    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**

            throws ArtifactMetadataRetrievalException {
        Set<Artifact> dependencies = new HashSet<>();

        if ("g".equals(artifact.getArtifactId())) {
            Artifact a = null;
            try {
                a = factory.createBuildArtifact("org.apache.maven", "h", "1.0", "jar");
                dependencies.add(a);
            } catch (Exception e) {

     */
    public static Writer create(final OutputStream os, final String encoding) {
        assertArgumentNotNull("os", os);
        assertArgumentNotEmpty("encoding", encoding);

        try {
            return new OutputStreamWriter(os, encoding);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

  @SuppressSignatureCheck
  override fun clean(
    chain: List<Certificate>,
    hostname: String,
  ): List<Certificate> {
    val certificates = (chain as List<X509Certificate>).toTypedArray()
    try {
      return x509TrustManagerExtensions.checkServerTrusted(certificates, "RSA", hostname)
    } catch (ce: CertificateException) {
      throw SSLPeerUnverifiedException(ce.message).apply { initCause(ce) }
    }
  }

            return null;
        }

        List<SmbFile> files = new ArrayList<>();
        for (DirectoryCacheEntry.FileInfo fileInfo : entry.getChildren()) {
            try {
                // Create SmbFile objects from cached info
                SmbFile file = createSmbFileFromCache(directoryPath, fileInfo);
                files.add(file);
            } catch (Exception e) {

        try {
            Field field = findField(obj.getClass(), fieldName);
            field.setAccessible(true);
            field.set(obj, value);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set field " + fieldName, e);
        }
    }

    private Object getFieldValue(Object obj, String fieldName) {
        try {

        try {
            final Method method = CustomSize.class.getMethod("minKey");
            final Object defaultValue = method.getDefaultValue();
            return defaultValue != null ? defaultValue.toString() : StringUtil.EMPTY;
        } catch (final Exception e) {
            return StringUtil.EMPTY;
        }
    }

    private String getDefaultMaxKey() {
        try {

            throwValidationErrorApi(messages -> {
                messages.addErrorsCrudFailedToCreateInstance(GLOBAL);
            });
            return null;
        });
        try {
            roleService.store(entity);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);

        server.setHandler(handlers);
    }

    public void start() {
        try {
            server.start();
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        }
    }

    public void stop() {
        try {
            server.stop();
            server.join();
        } catch (final Exception e) {

     * @return a <code>JarFile</code> to read the specified JAR file
     */
    public static JarFile create(final String file) {
        assertArgumentNotNull("file", file);

        try {
            return new JarFile(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**