try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    throw new CrawlingAccessException(e);
                }
                return null;
            }
        };
        client.setAccessTimeout(1);
        try {
            client.doGet("smb://localhost/test.txt");
            fail();
        } catch (CrawlingAccessException e) {

        .createTestSuite();
  }

  // TODO: consider being null-hostile in these tests

  private static Test testsForHashMapNullKeysForbidden() {
    return wrappedHashMapTests(
        new WrappedHashMapGenerator() {
          @Override
          Map<String, String> wrap(final HashMap<String, String> map) {
            if (map.containsKey(null)) {
              throw new NullPointerException();
            }

    // to propagate immediately.
    Exception exception = null;
    for (BaseStream<?, ?> stream : toClose) {
      try {
        stream.close();
      } catch (Exception e) { // sneaky checked exception
        if (exception == null) {
          exception = e;
        } else {
          exception.addSuppressed(e);
        }
      }
    }
    if (exception != null) {

    }

    public String getReading() {
        return reading;
    }

    public String getPos() {
        return pos;
    }

    public boolean isUpdated() {
        return newToken != null;
    }

    public boolean isDeleted() {
        return isUpdated() && newToken.length() == 0;
    }

    @Override
    public int hashCode() {

    boolean ran = false;
    @Nullable Callback callback = null;

    public SimpleTearDown() {}

    public SimpleTearDown(Callback callback) {
      this.callback = callback;
    }

    @Override
    public void tearDown() throws Exception {
      if (callback != null) {
        callback.run();
      }
      ran = true;
    }
  }

  @Override
  public boolean contains(@CheckForNull Object target) {
    @Nullable Object[] table = this.table;
    if (target == null || table.length == 0) {
      return false;
    }
    for (int i = Hashing.smearedHash(target); ; i++) {
      i &= mask;
      Object candidate = table[i];
      if (candidate == null) {
        return false;
      } else if (candidate.equals(target)) {
        return true;
      }
    }
  }

     * @return file representing the tool executable, or null if the tool cannot be found
     */
    String findTool(String toolName);

    /**
     * Let the toolchain decide if it matches requirements defined
     * in the toolchain plugin configuration.
     *
     * @param requirements key value pair, may not be {@code null}
     * @return {@code true} if the requirements match, otherwise {@code false}
     */

    private static class OptionComparator implements Comparator<Option> {
        public int compare(Option opt1, Option opt2) {
            String s1 = opt1.getOpt() != null ? opt1.getOpt() : opt1.getLongOpt();
            String s2 = opt2.getOpt() != null ? opt2.getOpt() : opt2.getLongOpt();
            return s1.compareToIgnoreCase(s2);
        }
    }

    private static class CLIManagerExtension extends CLIManager {

                                "required": False,
                                "schema": IsDict(
                                    {
                                        "anyOf": [{"type": "string"}, {"type": "null"}],
                                        "title": "Fatebook Tracker",
                                    }
                                )
                                | IsDict(

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import jcifs.CIFSUnsupportedCryptoException;


/**
 * @author mbechler
 *
 */
public final class Crypto {

    private static Provider provider = null;


    /**
     * 
     */
    private Crypto () {}


    /**
     * 
     * @return MD4 digest
     */
    public static MessageDigest getMD4 () {
        try {