/**
 * Base class for all maven exceptions.
 *
 * @since 4.0.0
 */
@Experimental
public class MavenException extends RuntimeException {

    @Serial
    private static final long serialVersionUID = 9027638326336093132L;

    public MavenException() {}

    public MavenException(String message) {
        super(message);
    }

    public MavenException(String message, Throwable cause) {

      "preferredLanguage" : {
        "type" : "keyword"
      },
      "departmentNumber" : {
        "type" : "keyword"
      },
      "uidNumber" : {
        "type" : "long"
      },
      "gidNumber" : {
        "type" : "long"
      },
      "homeDirectory" : {
        "type" : "keyword"
      },
      "groups": {
        "type": "keyword"
      },
      "roles": {

        assertEquals(Constants.HEAD_METHOD, response.getMethod());
    }

    static class TestClient implements CrawlerClient {
        int count;

        int exceptionCount;

        long interval = 500;

        long previousTime;

        @Override
        public void setInitParameterMap(final Map<String, Object> params) {
        }

        /*
         * (non-Javadoc)
         *

   * @see FileChannel#map(MapMode, long, long)
   * @since 2.0
   */
  public static MappedByteBuffer map(File file) throws IOException {
    checkNotNull(file);
    return map(file, MapMode.READ_ONLY);
  }

  /**
   * Fully maps a file in to memory as per {@link
   * FileChannel#map(java.nio.channels.FileChannel.MapMode, long, long)} using the requested {@link
   * MapMode}.
   *

        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    @Override
    public String toString() {

    }
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    synchronized (lock) {
      while (true) {
        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;
        } else {
          long now = System.nanoTime();
          NANOSECONDS.timedWait(lock, nanos);

  private final ImmutableList<Entry<E>> entries;
  private final long size;

  static <E> ImmutableMultiset<E> create(Collection<? extends Entry<? extends E>> entries) {
    @SuppressWarnings("unchecked")
    Entry<E>[] entriesArray = entries.toArray((Entry<E>[]) new Entry<?>[0]);
    Map<E, Integer> delegateMap = Maps.newHashMapWithExpectedSize(entriesArray.length);
    long size = 0;
    for (int i = 0; i < entriesArray.length; i++) {

        final int num = 100;
        long start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            System.out.println("test" + i);
        }
        final long sysout = System.currentTimeMillis() - start;
        start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            logger.fatal("test" + i);
        }
        final long logger = System.currentTimeMillis() - start;

final class Hashing {
  private Hashing() {}

  /*
   * These should be ints, but we need to use longs to force GWT to do the multiplications with
   * enough precision.
   */
  private static final long C1 = 0xcc9e2d51;
  private static final long C2 = 0x1b873593;

  /*
   * This method was rewritten in Java from an intermediate step of the Murmur hash function in

  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    throwIf(closed);
    throwIf(READ_THROWS);
    return in.read(b, off, len);
  }

  @Override
  public long skip(long n) throws IOException {
    throwIf(closed);
    throwIf(SKIP_THROWS);
    return in.skip(n);
  }

  @Override
  public int available() throws IOException {
    throwIf(closed);