if (setterInfo == null) {
            // Look for any method named "set" with one parameter
            Map<String, MethodInfo> classMethodCache = METHOD_CACHE.computeIfAbsent(beanType, this::buildMethodCache);
            setterInfo = classMethodCache.get("set");
        }

        if (setterInfo == null) {

            if (allProjects != null) {
                Map<String, Map<String, Map<String, MavenProject>>> map = new HashMap<>();
                allProjects.forEach(project -> map.computeIfAbsent(project.getGroupId(), k -> new HashMap<>())
                        .computeIfAbsent(project.getArtifactId(), k -> new HashMap<>())
                        .put(project.getVersion(), project));
                this.allProjects = map;
            } else {

        } else {
            textBuilder.append(value).append(lineSeparator);
        }

        // Add to metadata if at top level
        if (depth <= 1 && StringUtil.isNotBlank(key)) {
            metadataMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
        }
    }

    /**
     * Builds a nested key path.
     *
     * @param parentKey the parent key
     * @param currentKey the current key

        if (StringUtil.isBlank(value)) {
            return Collections.emptyList();
        }
        return split(value, ",").get(stream -> stream.map(String::trim)//
                .map(s -> clientRuleCache.computeIfAbsent(s, t -> {
                    final String[] values = t.split(":", 2);
                    if (values.length != 2) {
                        return null;
                    }

    assertThrows(UnsupportedOperationException.class, () -> unmod.replace(3, "four"));
    assertThrows(
        UnsupportedOperationException.class, () -> unmod.computeIfAbsent(3, k -> k + "three"));
    assertThrows(UnsupportedOperationException.class, () -> unmod.computeIfPresent(4, (k, v) -> v));
    assertThrows(UnsupportedOperationException.class, () -> unmod.compute(4, (k, v) -> v));

                        findLastLocalParentForPluginManagement(context, tempPomPath, pomMap, tempDir, commonRoot);

                if (targetPomForManagement != null) {
                    result.computeIfAbsent(targetPomForManagement, k -> new HashSet<>())
                            .addAll(pluginsNeedingUpgrade);

                    if (!pluginsNeedingUpgrade.isEmpty()) {

            ModelBuilderResult result;
            try {
                ModelTransformer injector = (m, r, p) -> {
                    MavenProject project = projectIndex.computeIfAbsent(m.getId(), f -> new MavenProject());
                    return injectLifecycleBindings(m, r, p, project, request);
                };
                ModelBuilderRequest modelBuildingRequest = getModelBuildingRequest()

    }

    @Override
    public @Nullable V replace(K key, V value) {
      throw new UnsupportedOperationException();
    }

    @Override
    public V computeIfAbsent(
        K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
      throw new UnsupportedOperationException();
    }

    @Override
    public @Nullable V computeIfPresent(

          }
        };
    Cache<Object, Object> cache =
        CacheBuilder.newBuilder().removalListener(removalListener).build();
    cache.put("a", "b");
    cache.asMap().computeIfAbsent("a", k -> "c");
    assertThat(notifications).isEmpty();
  }

  public void testCopyEntry_computing() {
    CountDownLatch startSignal = new CountDownLatch(1);

     *
     * @param index the index name
     * @param path  path to the configuration file
     */
    public void addConfigFile(final String index, final String path) {
        configListMap.computeIfAbsent(index, k -> new ArrayList<>()).add(path);
    }

    /**
     * Sets the configuration settings for the search engine.
     *
     * @param settings map of configuration key-value pairs
     */