for (int i = 0; i < VALUES.length; i++) {
        List<Double> list = Doubles.asList(VALUES).subList(0, i);
        Collection<Double> misleadingSize = Helpers.misleadingSizeCollection(delta);
        misleadingSize.addAll(list);
        double[] arr = Doubles.toArray(misleadingSize);
        assertThat(arr.length).isEqualTo(i);
        for (int j = 0; j < i; j++) {
          assertThat(arr[j]).isEqualTo(VALUES[j]);
        }
      }

    // combinations of finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      accumulator.addAll(values.asIterable());
      double min = accumulator.snapshot().min();
      if (values.hasAnyNaN()) {
        assertWithMessage("min of " + values).that(min).isNaN();
      } else if (values.hasAnyNegativeInfinity()) {

  }

  /**
   * Returns a set of all key-value pairs. Changes to the returned set will update the underlying
   * multimap, and vice versa. The entries set does not support the {@code add} or {@code addAll}
   * operations.
   *
   * <p>The iterator generated by the returned set traverses the entries in the order they were
   * added to the multimap.
   *

            for (ArtifactRepository aliasedRepo : aliasedRepos) {
                releasePolicies.add(aliasedRepo.getReleases());
                mirroredRepos.addAll(aliasedRepo.getMirroredRepositories());
            }

            ArtifactRepositoryPolicy releasePolicy = getEffectivePolicy(releasePolicies);

                importResult = build(importRequest, importIds);
            } catch (ModelBuildingException e) {
                problems.addAll(e.getProblems());
                return null;
            }

            problems.addAll(importResult.getProblems());

            importModel = importResult.getEffectiveModel();
        }

    // If we're set to a default port, unset it in case of a scheme change.
    result.port = if (port != defaultPort(scheme)) port else -1
    result.encodedPathSegments.clear()
    result.encodedPathSegments.addAll(encodedPathSegments)
    result.encodedQuery(encodedQuery)
    result.encodedFragment = encodedFragment
    return result
  }

  /**

   * 1}, this method has the identical effect to {@link #add(Object)}. This method is functionally
   * equivalent (except in the case of overflow) to the call {@code
   * addAll(Collections.nCopies(element, occurrences))}, which would presumably perform much more
   * poorly.
   *
   * @param element the element to add occurrences of; may be null only if explicitly allowed by the

          // adds recursive isSubtypeOf() call and feels complicated.
          // There is no contract one way or another as long as isSubtypeOf() works as expected.
          combined.addAll(asList(typeParam.getBounds()));
          if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound.
            combined.remove(Object.class);
          }

        final String key = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
        if (StringUtil.isNotBlank(key)) {
            tags = ArrayUtils.addAll(tags, key);
        }
        final String[] fields = request.getParameterValues("field");

        final PopularWordHelper popularWordHelper = ComponentUtil.getPopularWordHelper();

    // We can't use Lists.asList() here because there's no hash->collect dependency
    List<HashFunction> list = new ArrayList<>();
    list.add(first);
    list.add(second);
    Collections.addAll(list, rest);
    return new ConcatenatedHashFunction(list.toArray(new HashFunction[0]));
  }

  /**
   * Returns a hash function which computes its hash code by concatenating the hash codes of the