}
    }
  }

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

    for (Entry<K, V> entry : entries) {
      resetContainer();

      K k = entry.getKey();
      V v = entry.getValue();

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

	var res AccElem
	minutes := time.Now().Unix() / 60
	l.forwardTo(minutes)
	for _, elem := range l.Totals[:] {
		res.merge(elem)
	}
	return res
}

// forwardTo time t, clearing any entries in between.
func (l *ReplicationLastHour) forwardTo(t int64) {
	if l.LastMin >= t {
		return
	}
	if t-l.LastMin >= 60 {
		l.Totals = [60]AccElem{}
		return
	}
	for l.LastMin != t {

              .sampleKeys()
              .e0();
      Object[] entries = new Object[elements.length];
      for (int i = 0; i < elements.length; i++) {
        @SuppressWarnings("unchecked") // These come from Entry<K, V> objects somewhere.
        V value = (V) elements[i];
        entries[i] = mapEntry(k, value);
      }
      return multimapGenerator.create(entries).values();
    }

    @Override

  public void testEntries() {
    assertEqualIgnoringOrder(getSampleElements(), multimap().entries());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testContainsEntryWithNullKeyPresent() {
    initMultimapWithNullKey();
    assertContains(multimap().entries(), mapEntry((K) null, getValueForNullKey()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)

    Collection<Entry<K, V>> entries = multimap().entries();
    assertFalse(entries.contains(mapEntry(k3(), v3())));
    multimap().put(k3(), v3());
    assertContains(entries, mapEntry(k3(), v3()));
  }

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

    Collection<Entry<K, V>> entries = multimap().entries();
    assertFalse(entries.contains(mapEntry(k3(), v3())));
    multimap().put(k3(), v3());
    assertContains(entries, mapEntry(k3(), v3()));
  }

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

      // Start with a suitably shaped collection of entries
      Collection<Entry<K, V>> originalEntries = mapGenerator.getSampleElements(elements.length);

      // Create a copy of that, with the desired value for each key
      Collection<Entry<K, V>> entries = new ArrayList<>(elements.length);
      int i = 0;
      for (Entry<K, V> entry : originalEntries) {
        entries.add(mapEntry(keysArray[i++], entry.getValue()));
      }

import static java.util.Objects.requireNonNull;

/**
 * Early CLI {@link Logger} that simply accumulates log entries until some point a real logger can emit them. This
 * logger is created at start, and it exists while no logging is available yet.
 */
public class AccumulatingLogger implements Logger {
    private final AtomicReference<List<Entry>> entries = new AtomicReference<>(new CopyOnWriteArrayList<>());

    @Override

        throw new UnsupportedOperationException("Cannot get available versions in this test case");
    }

    @Override
    public ResolutionGroup retrieve(MetadataResolutionRequest request) throws ArtifactMetadataRetrievalException {
        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

    @Override

    @Param(value = { "10000000" })
    int entries;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVLong(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVLong(Long.MAX_VALUE - i);
        }