protected final CountDownLatch runLatch = new CountDownLatch(1);
  protected final CountDownLatch taskLatch = new CountDownLatch(1);
  protected final CountDownLatch listenerLatch = new CountDownLatch(1);

  protected volatile boolean throwException = false;

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override

    } catch (NoSuchAlgorithmException e) {
      throw new AssertionError(e);
    }
  }

  @Override
  public Hasher newHasher() {
    if (supportsClone) {
      try {
        return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes);
      } catch (CloneNotSupportedException e) {
        // falls through
      }
    }
    return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes);

      @Override
      public Checksum get() {
        return new CRC32();
      }
    },
    ADLER_32("Hashing.adler32()") {
      @Override
      public Checksum get() {
        return new Adler32();
      }
    };

    public final HashFunction hashFunction;

    ChecksumType(String toString) {
      this.hashFunction = new ChecksumHashFunction(this, 32, toString);
    }
  }

  /**

                    p = iface.indexOf('.', c + 1);
                    this.uuid = new UUID(iface.substring(0, c));
                    this.major = Integer.parseInt(iface.substring(c + 1, p));
                    this.minor = Integer.parseInt(iface.substring(p + 1));
                    return;
                }
            }
            throw new DcerpcException("Bad endpoint: " + this.endpoint);
        }

    }

    /**
     * Gets the delay in milliseconds for waiting for new URLs.
     * @return delay in milliseconds
     */
    public long getDelayMillisForWaitingNewUrl() {
        return delayMillisForWaitingNewUrl;
    }

    /**
     * Sets the delay in milliseconds for waiting for new URLs.
     * @param delayMillisForWaitingNewUrl delay in milliseconds
     */

    private final List<Pair<String, String>> searchFieldLogList = new ArrayList<>();

    private final List<Pair<String, String>> headerList = new ArrayList<>();

    private OptionalEntity<UserInfo> userInfo;

    private Map<String, Object> fields;

    private final List<Map<String, Object>> documentList = new ArrayList<>();

    @Override
    public String getId() {
        return asDocMeta().id();

    logger.fine("   Sizes: " + formatFeatureSet(sizesToTest));

    if (sizesToTest.isEmpty()) {
      throw new IllegalStateException(
          name
              + ": no CollectionSizes specified (check the argument to "
              + "FeatureSpecificTestSuiteBuilder.withFeatures().)");
    }

    TestSuite suite = new TestSuite(name);
    for (Feature<?> collectionSize : sizesToTest) {
      String oneSizeName =

                    currentSegment = new TaskSegment(aggregating);
                    taskSegments.add(currentSegment);
                }

                currentSegment.getTasks().add(new GoalTask(task));
            } else {
                // lifecycle phase

                if (currentSegment == null || currentSegment.isAggregating()) {
                    currentSegment = new TaskSegment(false);

        boolean toInclusive) {
      return new NavigableElementSet<>(
          multiset()
              .subMultiset(
                  fromElement, BoundType.forBoolean(fromInclusive),
                  toElement, BoundType.forBoolean(toInclusive)));
    }

    @Override
    public NavigableSet<E> headSet(@ParametricNullness E toElement, boolean inclusive) {
      return new NavigableElementSet<>(

      enumConstantCache = new WeakHashMap<>();

  private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache(
      Class<T> enumClass) {
    Map<String, WeakReference<? extends Enum<?>>> result = new HashMap<>();
    for (T enumInstance : EnumSet.allOf(enumClass)) {
      result.put(enumInstance.name(), new WeakReference<Enum<?>>(enumInstance));
    }