*
     * @param algorithm
     *            アルゴリズム (利用可能なアルゴリズムは{@link MessageDigest}のJavadoc等を参照してください)。
     *            {@literal null}や空文字列であってはいけません
     * @return {@link MessageDigest}
     * @throws RuntimeException
     *             {@link NoSuchAlgorithmException}が発生した場合
     */
    public static MessageDigest getInstance(final String algorithm) {
        assertArgumentNotEmpty("algorithm", algorithm);

        try {

import java.util.List;

/**
 * CleanArgument
 */
public class CleanArgument {
    public static String[] cleanArgs(String[] args) {
        try {
            return doCleanArgs(args);
        } catch (RuntimeException e) {
            for (String a : args) {
                System.out.println("Arg: '" + a + "'");
            }
            throw e;
        }
    }

    private static String[] doCleanArgs(String[] args) {

    }.socketFactory
  }

  companion object {
    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.
        Class.forName("org.conscrypt.Conscrypt\$Version", false, javaClass.classLoader)

        when {
          // Bump this version if we ever have a binary incompatibility

        }
      },
    )

    check(latch.await(10, TimeUnit.SECONDS)) { "Timed out waiting for count." }

    val failure = failureRef.get()
    if (failure != null) {
      throw RuntimeException(failure)
    }

    return countRef.get()
  }

  private fun updateReports() {
    val latch = CountDownLatch(1)
    newWebSocket(
      "/updateReports?agent=$USER_AGENT",

        File psOutFile = new File(rootProjectDir, timestamp + ".psoutput");

        try {
            Files.write(psOutFile.toPath(), psOutput);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static void cleanPsOutputAndThreaddumpFilesFromPreviousRun(File rootProjectDir) {
        if (executionMode == ExecutionMode.KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS) {

      runCalled = true;
      assertEquals(State.RUNNING, state());

      enterRun.countDown();
      try {
        exitRun.await();
      } catch (InterruptedException e) {
        throw new RuntimeException(e);
      }
    }

    @Override
    protected void shutDown() {
      assertTrue(startUpCalled);
      assertTrue(runCalled);
      assertFalse(shutDownCalled);
      shutDownCalled = true;

        }
    }

    /**
     *
     */
    public class TestDisposable2 implements Disposable {
        @Override
        public void dispose() {
            ++count;
            throw new RuntimeException();
        }
    }

     */
    public InputSource clone() {
        try {
            InputSource copy = (InputSource) super.clone();

            return copy;
        } catch (Exception ex) {
            throw (RuntimeException)
                    new UnsupportedOperationException(getClass().getName() + " does not support clone()").initCause(ex);
        }
    } // -- InputSource clone()

    /**

                reader.read(is, true, new InputSource("id", pom.toString()));
                i++;
            } catch (XMLStreamException e) {
                throw new RuntimeException("Error parsing: " + pom, e);
            }
        }
        return i;
    }

    /**
     * <p>main.</p>
     *
     * @param args a {@link String} object.

    Runnable runMe =
        new Runnable() {
          @Override
          public void run() {
            numCalls.incrementAndGet();
            throw new RuntimeException("FAKE EXCEPTION!");
          }
        };

    e.execute(runMe);
    e.execute(runMe);
    fakePool.runAll();

    assertEquals(2, numCalls.get());
  }