@Override
    public CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter) {
        Objects.requireNonNull(projectRealm, "projectRealm cannot be null");

        if (cache.containsKey(key)) {
            throw new IllegalStateException("Duplicate project realm for extensions " + key);
        }

        CacheRecord record = new CacheRecord(projectRealm, extensionArtifactFilter);

                    fieldName = null;
                }
                buffer.setLength(0);
            } else if ("list".equals(qName)) {
                if (fieldName != null && !dataMap.containsKey(fieldName)) {
                    dataMap.put(fieldName, new ArrayList<>());
                }
            } else if ("item".equals(qName)) {
                buffer.setLength(0);
            }
        }

                final String value = filetypeField + ":" + fileType;
                if (!values.contains(value)) {
                    final String key = "labels.facet_filetype_" + fileType;
                    if (resources.containsKey(key)) {
                        queryMap.put(key, value);
                    } else {
                        queryMap.put(fileType.toUpperCase(Locale.ROOT), value);
                    }
                }

        .put("foo", 3)
        .build();
  }

  public void testMultimapReads() {
    Multimap<String, Integer> multimap = createMultimap();
    assertTrue(multimap.containsKey("foo"));
    assertFalse(multimap.containsKey("cat"));
    assertTrue(multimap.containsValue(1));
    assertFalse(multimap.containsValue(5));
    assertTrue(multimap.containsEntry("foo", 1));
    assertFalse(multimap.containsEntry("cat", 1));

        }

        @Override
        public boolean onStartElement(String elementName, Map<String, String> attributes) {
            if (!elementName.equals("a") || !attributes.containsKey("name")) {
                return false;
            }
            Element element = document.createElement("anchor");
            String id = String.format("%s.%s", classMetaData.getClassName(), attributes.get("name"));

                    HashSet<String> usedProperties = new HashSet<>();
                    newVersion = interpolator.interpolate(version.trim(), property -> {
                        if (!session.getConfigProperties().containsKey(property)) {
                            throw new IllegalArgumentException("Cannot inline property " + property);
                        }
                        usedProperties.add(property);

        Plugin testPlugin = null;

        for (Plugin plugin : plugins) {
            String pluginArtifactId = plugin.getArtifactId();

            assertTrue(validPluginCounts.containsKey(pluginArtifactId), "Illegal plugin found: " + pluginArtifactId);

            if (pluginArtifactId.equals(testPluginArtifactId)) {
                testPlugin = plugin;
            }

            }

            Path moduleDirectory = baseDirectory.resolve(moduleName);
            Path modulePomPath = moduleDirectory.resolve(POM_XML);

            if (Files.exists(modulePomPath) && !pomMap.containsKey(modulePomPath)) {
                Document modulePom = loadPom(modulePomPath);
                pomMap.put(modulePomPath, modulePom);

                // Recursively discover sub-modules

                ?: return validSubprojects.map { SmallSubprojectBucket(it, ParallelizationMethod.None) }

        validSubprojects.forEach {
            if (!subProjectToClassTimes.containsKey(it.name)) {
                subProjectToClassTimes[it.name] = emptyList()
            }
        }

        val subProjectTestClassTimes: List<SubprojectTestClassTime> =
            subProjectToClassTimes

    }

    // TODO(lowasser): consider an optimized values() implementation

    @Override
    public boolean containsKey(@Nullable Object key) {
      return keyIndex.containsKey(key);
    }

    @Override
    public @Nullable V get(@Nullable Object key) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        return null;