Collection<? extends V> valueCollection = (Collection<? extends V>) values;
      return !valueCollection.isEmpty() && get(key).addAll(valueCollection);
    } else {
      Iterator<? extends V> valueItr = values.iterator();
      return valueItr.hasNext() && Iterators.addAll(get(key), valueItr);
    }
  }

  @CanIgnoreReturnValue
  @Override
  public boolean putAll(Multimap<? extends K, ? extends V> multimap) {

                identifiable.setSourceLevel(recessiveSourceLevel);

                identifiables.add(identifiable);
            }
        }

        dominant.addAll(0, identifiables);
    }

    /**
     * @param identifiables
     * @return a map
     */
    private static <T extends IdentifiableBase> Map<String, T> mapById(List<T> identifiables) {

            if (StringUtil.isNotBlank(baseDn) && StringUtil.isNotBlank(accountFilter)) {
                final LdapManager ldapManager = ComponentUtil.getLdapManager();
                permissions = distinct(ArrayUtils.addAll(ldapManager.getRoles(this, baseDn, accountFilter, groupFilter, roles -> {
                    permissions = distinct(roles);

    }

    public void add(ModelProblem problem) {
        problems.add(problem);

        severities.add(problem.getSeverity());
    }

    public void addAll(List<ModelProblem> problems) {
        this.problems.addAll(problems);

        for (ModelProblem problem : problems) {
            severities.add(problem.getSeverity());
        }
    }

    @Override

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

      List<V> expectedValues = copyToList(multimap().get(k));

      assertTrue(multimap().putAll(k, values));
      expectedValues.addAll(values);

      assertGet(k, expectedValues);
    }
  }

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

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

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

      assertGet(k, expectedValues);
    }
  }

    multiset = ConcurrentHashMultiset.create(map);
    multiset.addAll(ImmutableList.of("a", "a", "b", "c", "d", "b"));
    reserializeAndAssert(multiset);
  }

  public void testSerializationWithMapMaker3() {
    ConcurrentMap<String, AtomicInteger> map = new MapMaker().makeMap();
    multiset = ConcurrentHashMultiset.create(map);
    multiset.addAll(ImmutableList.of("a", "a", "b", "c", "d", "b"));

            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);
  }

        getAddAllUnsupportedSomePresentMethod());
  }

  @Override
  protected Collection<Method> suppressForConcurrentSkipListMap() {
    List<Method> methods = newArrayList();
    methods.addAll(super.suppressForConcurrentSkipListMap());
    methods.add(getContainsEntryWithIncomparableKeyMethod());
    methods.add(getContainsEntryWithIncomparableValueMethod());
    return methods;
  }