for (K k : sampleKeys()) {
      resetContainer();

      Set<V> expectedValues = copyToSet(multimap().get(k));

      multimap().putAll(k, valuesToPut);
      expectedValues.addAll(valuesToPut);

      assertGet(k, expectedValues);
    }
  }

    EnumSetAccumulator<E> combine(EnumSetAccumulator<E> other) {
      if (this.set == null) {
        return other;
      } else if (other.set == null) {
        return this;
      } else {
        this.set.addAll(other.set);
        return this;
      }
    }

    ImmutableSet<E> toImmutableSet() {
      if (set == null) {
        return ImmutableSet.of();
      }

      @Override
      protected Multiset<String> create(String[] elements) {
        Multiset<String> multiset = LinkedHashMultiset.create();
        Collections.addAll(multiset, elements);
        multiset.addAll(ELEMENTS_TO_FILTER_OUT);
        return Multisets.filter(multiset, PREDICATE);
      }

      @Override
      public List<String> order(List<String> insertionOrder) {

      E e1, E e2, E e3, E e4, E e5, E e6, E... remaining) {
    int size = remaining.length + 6;
    List<E> all = Lists.newArrayListWithCapacity(size);
    Collections.addAll(all, e1, e2, e3, e4, e5, e6);
    Collections.addAll(all, remaining);
    return copyOf(Ordering.natural(), all);
  }

  /**
   * Returns an immutable sorted multiset containing the given elements sorted by their natural
   * ordering.

            duplicateHostList = new ArrayList<>();
        }
        final DuplicateHostService duplicateHostService = ComponentUtil.getComponent(DuplicateHostService.class);
        duplicateHostList.addAll(duplicateHostService.getDuplicateHostList());
    }

    public void setDuplicateHostList(final List<DuplicateHost> duplicateHostList) {
        this.duplicateHostList = duplicateHostList;
    }

      }
    },
    BUILDER_ADD_ALL_COLLECTION {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {
        ImmutableMultiset.Builder<Object> builder = ImmutableMultiset.builder();
        builder.addAll(keys);
        return builder.build();
      }
    };

    @CanIgnoreReturnValue
    @Override
    public abstract ImmutableMultiset<Object> create(List<?> keys);
  }

     */
    public SettingsBuildingException(List<SettingsProblem> problems) {
        super(toMessage(problems));

        this.problems = new ArrayList<>();
        if (problems != null) {
            this.problems.addAll(problems);
        }
    }

    /**
     * Gets the problems that caused this exception.
     *
     * @return The problems that caused this exception, never {@code null}.
     */

                if (artifactRequest != null && artifactRequest.getRepositories() != null) {
                    repositories.addAll(artifactRequest.getRepositories());
                } else if (artifactDescriptorRequest != null && artifactDescriptorRequest.getRepositories() != null) {
                    repositories.addAll(artifactDescriptorRequest.getRepositories());
                }
                if (!repositories.isEmpty()) {

            }

            Collection<String> versions =
                    new LinkedHashSet<>(recessive.getVersioning().getVersions());
            versions.addAll(versioning.getVersions());
            versioning.setVersions(new ArrayList<>(versions));
        }

        // just carry-on as-is
        if (!recessive.getPlugins().isEmpty()) {

            return pair;
        }).forEach(additionalDefaultList::add));
    }

    public void setNotAnalyzedFields(final String[] fields) {
        notAnalyzedFieldSet = new HashSet<>();
        Collections.addAll(notAnalyzedFieldSet, fields);
    }

    protected boolean isSortField(final String field) {
        for (final String f : sortFields) {
            if (f.equals(field)) {
                return true;