* @throws IllegalArgumentException if the call would result in more than {@link
   *     Integer#MAX_VALUE} occurrences of {@code element} in this multiset.
   */
  @CanIgnoreReturnValue
  @Override
  public int add(@ParametricNullness E element, int occurrences) {
    if (occurrences == 0) {
      return count(element);
    }
    checkArgument(occurrences > 0, "occurrences cannot be negative: %s", occurrences);

        final List<String> items = new ArrayList<>();
        for (int i = 0; i < 32; i++) {
            items.add(Integer.toString(i));
        }
        for (int i = 40; i < 370; i += 10) {
            items.add(Integer.toString(i));
        }
        items.add(Integer.toString(365));
        return items;
    }

        }

        if (!d.getExclusions().isEmpty()) {
            List<String> exclusions = new ArrayList<>();

            for (Exclusion exclusion : d.getExclusions()) {
                exclusions.add(exclusion.getGroupId() + ':' + exclusion.getArtifactId());
            }

            artifact.setDependencyFilter(new ExcludesArtifactFilter(exclusions));
        }

        return artifact;
    }

        for (Map<String, Object> elem : logList) {
            if (elem.containsKey("job_name") && elem.get("job_name").equals(namePrefix + "Scheduler")) {
                resList.add(elem);
            }
        }
        return resList;
    }

    protected static List<Map<String, Object>> readLogItems(final String apiName) {
        final Map<String, Object> searchBody = new HashMap<>();

    }

    public void addFacetQueryView(final FacetQueryView facetQueryView) {
        facetQueryViewList.add(facetQueryView);
    }

    public List<FacetQueryView> getFacetQueryViewList() {
        return facetQueryViewList;
    }

    public void addInlineMimeType(final String mimeType) {
        inlineMimeTypeSet.add(mimeType);
    }

    public ActionHook getActionHook() {
        return actionHook;
    }

        List<String> scopes = new ArrayList<>(2);
        if (scopeToCollect != null && !scopeToCollect.isEmpty()) {
            scopes.add(scopeToCollect);
        }
        if (scopeToResolve != null && !scopeToResolve.isEmpty()) {
            scopes.add(scopeToResolve);
        }

        if (scopes.isEmpty()) {
            return null;
        } else {

            final List<String> tagList = new ArrayList<>();
            final String key = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
            if (StringUtil.isNotBlank(key)) {
                tagList.add(key);
            }
            runtime.registerData("popularWords", popularWordHelper.getWordList(SearchRequestType.SEARCH, null,
                    tagList.toArray(new String[tagList.size()]), null, null, null));
        }

        Stream.of("a", "b", "c"), Stream.of(1, 2, 3), (a, b) -> list.add(a + ":" + b));
    assertThat(list).containsExactly("a:1", "b:2", "c:3");
  }

  public void testForEachPair_differingLengths1() {
    List<String> list = new ArrayList<>();
    Streams.forEachPair(
        Stream.of("a", "b", "c", "d"), Stream.of(1, 2, 3), (a, b) -> list.add(a + ":" + b));
    assertThat(list).containsExactly("a:1", "b:2", "c:3");
  }

        if (file.isFile()) {
            result.setFile(file);
        }

        return result;
    }

    public void add(RepositorySystemSession session, LocalArtifactRegistration request) {
        // noop
    }

    public void add(RepositorySystemSession session, LocalMetadataRegistration request) {
        // noop
    }

    // the representable doubles are 2^54 and 2^54 + 4
    // 2^54+1 is less than halfway between, so HALF_DOWN and HALF_UP will both go down.
    new RoundToDoubleTester(BigDecimal.valueOf(1L << 54).add(new BigDecimal(0.5)))
        .setExpectation(twoToThe54, DOWN, FLOOR, HALF_DOWN, HALF_UP, HALF_EVEN)
        .setExpectation(Math.nextUp(twoToThe54), CEILING, UP)
        .roundUnnecessaryShouldThrow()
        .test();