super(HashBiMap.this);
    }

    @Override
    public boolean contains(@CheckForNull Object o) {
      if (o instanceof Entry) {
        Entry<?, ?> e = (Entry<?, ?>) o;
        Object k = e.getKey();
        Object v = e.getValue();
        int eIndex = findEntryByKey(k);
        return eIndex != ABSENT && Objects.equal(v, values[eIndex]);
      }
      return false;
    }

    @Override

                    Long classId = classEntry.getKey();
                    Map<Long, TestCaseRegion> regions = classEntry.getValue();

                    indexOutput.writeLong(classId, true);
                    indexOutput.writeInt(regions.size(), true);

                    for (Map.Entry<Long, TestCaseRegion> testCaseEntry : regions.entrySet()) {
                        long id = testCaseEntry.getKey();

            .flatMap(entry ->
                entry.getValue().roots()
                    .map(locationSnapshot -> immutableEntry(entry.getKey(), locationSnapshot.getHash())))
            .collect(toImmutableListMultimap(
                Map.Entry::getKey,
                Map.Entry::getValue
            ));
    }

        if (props != null && !props.isEmpty()) {
            serializer.startTag(NAMESPACE, tagName);
            for (Map.Entry<String, String> entry : props.entrySet()) {
                writeTag(entry.getKey(), null, entry.getValue(), serializer);
            }
            serializer.endTag(NAMESPACE, tagName);
        }
    }

    private void writeDom(XmlNode dom, XmlSerializer serializer) throws IOException {

                            final Map<String, Object> valueCount = new HashMap<>(2, 1f);
                            valueCount.put("value", e.getKey());
                            valueCount.put("count", e.getValue());
                            return valueCount;
                        }).collect(Collectors.toList()));
                        return fieldMap;

    }

    abstract ImmutableMap<K, Integer> keyToIndex();

    // True if getValue never returns null.
    private boolean isFull() {
      return size == keyToIndex().size();
    }

    K getKey(int index) {
      return keyToIndex().keySet().asList().get(index);
    }

    @CheckForNull
    abstract V getValue(int keyIndex);

    @Override
    ImmutableSet<K> createKeySet() {

                config.append(configMap.entrySet().stream().map(input -> {
                    if (input.getValue() == null) {
                        return input.getKey();
                    } else {
                        return input.getKey() + " = " + input.getValue();
                    }
                }).collect(Collectors.joining(", ")));
                config.append(")");
            }

            List<ConflictResolver> conflictResolvers)
            throws ArtifactResolutionException {
        fireEvent(ResolutionListener.TEST_ARTIFACT, listeners, node);

        Object key = node.getKey();

        // TODO Does this check need to happen here? Had to add the same call
        // below when we iterate on child nodes -- will that suffice?
        if (managedVersions.containsKey(key)) {

            // If the file is already present on this classpath, it keeps its transform (or lack thereof).
            if (!thisClassPathFiles.contains(appendedTransform.getKey())) {
                mergedTransforms.put(appendedTransform);
            }
        }

        // In the end, at most one instance of a transformed entry should be recorded for any given file.

                                + repository.getId() + " (" + repository.getUrl() + ")");
            }

            return false;
        }

        if (getLogger().isDebugEnabled()) {
            getLogger()
                    .debug("Determining update check for " + metadata.getKey() + " (" + file + ") from "