multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
    assertThat(multiset.toString()).isEqualTo("[foo x 2, bar]");
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = LinkedHashMultiset.create(50);
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));

      assertThat(graph.edges()).isEmpty();
      AbstractGraphTest.validateGraph(graph);

      while (graph.nodes().size() < NUM_NODES) {
        graph.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(graph.nodes());
      while (graph.edges().size() < NUM_EDGES) {
        graph.putEdge(getRandomElement(nodeList, gen), getRandomElement(nodeList, gen));
      }

  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_otherListWithDifferentElements() {
    ArrayList<E> other = new ArrayList<>(getSampleElements());
    other.set(other.size() / 2, getSubjectGenerator().samples().e3());
    assertFalse(
        "A List should not equal another List containing different elements.",
        getList().equals(other));
  }

          contents.ensureCapacity(Math.max(contents.size(), backingMap.size()));
          for (int i = backingMap.firstIndex(); i >= 0; i = backingMap.nextIndex(i)) {
            addCopies(backingMap.getKey(i), backingMap.getValue(i));
          }
        } else {
          Set<? extends Entry<? extends E>> entries = multiset.entrySet();
          contents.ensureCapacity(Math.max(contents.size(), entries.size())); // might overlap

        return true;
      }
      if (object instanceof LongArrayAsList) {
        LongArrayAsList that = (LongArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

        source.skip(dashDashBoundary.size.toLong())
      } else {
        // This is a subsequent part or a preamble. Skip until "\r\n--" followed by the boundary.
        while (true) {
          val toSkip = currentPartBytesRemaining(maxByteCount = 8192)
          if (toSkip == 0L) break
          source.skip(toSkip)
        }
        source.skip(crlfDashDashBoundary.size.toLong())
      }

        }
      }

      @Override
      public Iterator<Entry<K, V>> iterator() {
        return delegate().iterator();
      }

      @Override
      public int size() {
        return delegate().size();
      }

      @Override
      public boolean remove(Object o) {
        return delegate().remove(o);
      }

      @Override
      public void clear() {

    return delegate().rowKeySet();
  }

  @Override
  public Map<R, Map<C, V>> rowMap() {
    return delegate().rowMap();
  }

  @Override
  public int size() {
    return delegate().size();
  }

  @Override
  public Collection<V> values() {
    return delegate().values();
  }

  @Override
  public boolean equals(@Nullable Object obj) {

        List<V> expectedValues = copyToList(values);

        assertTrue(multimap().put(key, value));
        expectedValues.add(value);

        assertGet(key, expectedValues);
        assertEquals(value, values.get(values.size() - 1));
      }
    }
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutDuplicateValue() {
    List<Entry<K, V>> entries = copyToList(multimap().entries());

  RoundingMode mode;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      doubleInIntRange[i] = randomDouble(Integer.SIZE - 2);
      doubleInLongRange[i] = randomDouble(Long.SIZE - 2);
      positiveDoubles[i] = randomPositiveDouble();
    }
  }

  @Benchmark
  int roundToInt(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {