value = this.connection.getHeaderField(i);
        }
        for (final Entry<String, List<String>> entry : map.entrySet()) {
            entry.setValue(Collections.unmodifiableList(entry.getValue()));
        }
        return this.headerFields = Collections.unmodifiableMap(map);
    }

    @Override
    public Map<String, List<String>> getHeaderFields() {

        keptAccessors.entrySet().removeIf(e -> {
            if (seenUpgradedAccessorsChanges.contains(e.getKey())) {
                return true;
            }
            ReplacedAccessor accessor = e.getValue();
            return accessor.getBinaryCompatibility() == BinaryCompatibility.ACCESSORS_KEPT;
        });
        if (!keptAccessors.isEmpty()) {

    for (Entry<K, V> entry : getSampleElements()) {
      expected.add(entry.getValue());
    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testValuesInOrder() {
    List<V> expected = new ArrayList<>();
    for (Entry<K, V> entry : getOrderedElements()) {
      expected.add(entry.getValue());
    }
    assertEqualInOrder(expected, multimap().values());
  }

    stream.writeInt(multimap.asMap().size());
    for (Map.Entry<K, Collection<V>> entry : multimap.asMap().entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeInt(entry.getValue().size());
      for (V value : entry.getValue()) {
        stream.writeObject(value);
      }
    }
  }

  /**
   * Populates a multimap by reading an input stream, as part of deserialization. See {@link

    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();
    Entry<K, V> entry = iterator.next();
    K key = entry.getKey();
    V value = entry.getValue();
    multimap().removeAll(key);
    assertEquals(key, entry.getKey());
    assertEquals(value, entry.getValue());
  }

                    Map<String, String> map = CompactHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactHashMap")
            .withFeatures(
                CollectionSize.ANY,

        expectedHashCode,
        getMap().hashCode());
  }

  private static int hash(Entry<?, ?> e) {
    return (e.getKey() == null ? 0 : e.getKey().hashCode())
        ^ (e.getValue() == null ? 0 : e.getValue().hashCode());
  }

        testCoverageAndBuckets.associate { testCoverageAndBucket ->
            val testCoverage: TestCoverage = uuidToTestCoverage.getValue(testCoverageAndBucket["testCoverageUuid"].toString().toInt())
            val buckets: List<SmallSubprojectBucket> =
                (testCoverageAndBucket["buckets"] as List<Map<String, Any>>).map {

    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();
    Entry<K, V> entry = iterator.next();
    K key = entry.getKey();
    V value = entry.getValue();
    multimap().removeAll(key);
    assertEquals(key, entry.getKey());
    assertEquals(value, entry.getValue());
  }

            final String field = entry.getKey();
            if (excludeFields.contains(field)) {
                continue;
            }

            final Object value = entry.getValue();
            if (value == null) {
                continue;
            }

            if (!first) {
                json.append(",\n");
            }
            first = false;