}

// cloneCaches will return a clone of all current caches.
func (b *bucketMetacache) cloneCaches() (map[string]metacache, map[string][]string) {
	b.mu.RLock()
	defer b.mu.RUnlock()
	dst := make(map[string]metacache, len(b.caches))
	maps.Copy(dst, b.caches)
	// Copy indexes
	dst2 := make(map[string][]string, len(b.cachesRoot))
	for k, v := range b.cachesRoot {
		tmp := make([]string, len(v))
		copy(tmp, v)

     * map.remove(x)} returns the same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override
    public void testRemove() {
      Map<String, Map<Integer, Character>> map;
      try {
        map = makePopulatedMap();
      } catch (UnsupportedOperationException e) {
        return;
      }
      String keyToRemove = map.keySet().iterator().next();

func (z *MRFReplicateEntries) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "e"
	o = append(o, 0x82, 0xa1, 0x65)
	o = msgp.AppendMapHeader(o, uint32(len(z.Entries)))
	for za0001, za0002 := range z.Entries {
		o = msgp.AppendString(o, za0001)
		// map header, size 3
		// string "b"
		o = append(o, 0x83, 0xa1, 0x62)
		o = msgp.AppendString(o, za0002.Bucket)

   */
  private transient long size;

  /** Standard constructor. */
  protected AbstractMapBasedMultiset(Map<E, Count> backingMap) {
    checkArgument(backingMap.isEmpty());
    this.backingMap = backingMap;
  }

  /** Used during deserialization only. The backing map must be empty. */
  void setBackingMap(Map<E, Count> backingMap) {
    this.backingMap = backingMap;
  }

  // Required Implementations

  /**

    private List<String> blackList = new ArrayList<>();

    private Map<String, BuildFailure> buildFailuresByProject = new HashMap<>();

    private Map<String, Map<String, Map>> pluginContextsByProjectAndPluginKey = new HashMap<>();

    private String failureBehavior = FAIL_FAST;

    private final ProjectSorter sorter;

    private Map<String, BuildSuccess> buildSuccessesByProject = new HashMap<>();

  @SuppressWarnings("ConstantCaseForConstants")
  private static final Map<Class<?>, Class<?>> PRIMITIVE_TO_WRAPPER_TYPE;

  /** A map from wrapper types to their corresponding primitive types. */
  // It's a constant, and we can't use ImmutableMap here without creating a circular dependency.
  @SuppressWarnings("ConstantCaseForConstants")
  private static final Map<Class<?>, Class<?>> WRAPPER_TO_PRIMITIVE_TYPE;

package org.gradle.test

class GroovyClassWithParameterizedTypes {
    Set<CombinedInterface> setProp

    Map<CombinedInterface, GroovyClassWithParameterizedTypes> mapProp

    List<?> wildcardProp

    List<? extends CombinedInterface> upperBoundProp

    List<? super CombinedInterface> lowerBoundProp

    List<? super Set<? extends Map<?, CombinedInterface[]>>>[] nestedProp

    static <T> T paramMethod(T param) {
        null
    }

  @Override
  protected void assertMoreInvariants(Map<K, V> map) {
    // TODO: can these be moved to MapInterfaceTest?
    for (Entry<K, V> entry : map.entrySet()) {
      assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString());
    }

    assertEquals("{" + JOINER.join(map.entrySet()) + "}", map.toString());
    assertEquals("[" + JOINER.join(map.entrySet()) + "]", map.entrySet().toString());

     */
    public static boolean shouldAcceptForUpgradedProperty(JApiMethod jApiMethod, Violation violation, ViolationCheckContext context) {
        Map<AccessorKey, UpgradedProperty> currentAccessors = context.getUserData(CURRENT_ACCESSORS_OF_UPGRADED_PROPERTIES);
        Map<AccessorKey, ReplacedAccessor> oldRemovedAccessors = context.getUserData(OLD_REMOVED_ACCESSORS_OF_UPGRADED_PROPERTIES);

	type fields struct {
		activeBuckets map[BucketOptions]*bucketMeasurement
		endTime       time.Time
		update2       uint64
		endTime2      time.Time
	}
	start := time.Now()
	m0 := newBucketMeasurement(start)
	m0.incrementBytes(0)
	m1MiBPS := newBucketMeasurement(start)
	m1MiBPS.incrementBytes(oneMiB)

	test1Want := make(map[BucketOptions]Details)