}
            }
        }
        if (!unresolvedSelectors.isEmpty()) {
            String requiredSelectors = unresolvedSelectors.stream()
                    .filter(pas -> !pas.activationSettings().optional())
                    .map(ProjectActivation.ProjectActivationSettings::selector)
                    .collect(Collectors.joining(", "));
            if (!requiredSelectors.isEmpty()) {

                .getOrDefault(artifact.getGroupId(), Collections.emptyMap())
                .getOrDefault(artifact.getArtifactId(), Collections.emptyMap())
                .values()
                .stream()
                .filter(p -> Objects.nonNull(findArtifact(p, artifact, false)))
                .map(MavenProject::getVersion)
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
    }

import org.eclipse.aether.resolution.DependencyResolutionException;
import org.eclipse.aether.resolution.DependencyResult;
import org.eclipse.aether.util.filter.AndDependencyFilter;
import org.eclipse.aether.util.filter.ScopeDependencyFilter;
import org.eclipse.aether.util.graph.visitor.DependencyGraphDumper;
import org.eclipse.aether.util.repository.SimpleArtifactDescriptorPolicy;
import org.slf4j.Logger;

        ArrayList<CIInfo> result = ServiceLoader.load(CIDetector.class).stream()
                .map(ServiceLoader.Provider::get)
                .map(CIDetector::detectCI)
                .filter(Optional::isPresent)
                .map(Optional::get)
                .collect(Collectors.toCollection(ArrayList::new));

        if (result.size() > 1) {
            // remove generic

	PreserveETag                        string    // preserves this etag during a PUT call.
	NoLock                              bool      // indicates to lower layers if the caller is expecting to hold locks.
	HasIfMatch                          bool      // indicates if the request has If-Match header
	ProxyRequest                        bool      // only set for GET/HEAD in active-active replication scenario

                (scenarioDurations["durations"] as List<Map<String, Any>>).flatMap { duration ->
                    val testProject = duration["testProject"] as String
                    duration.entries
                        .filter { (key, _) -> key != "testProject" }
                        .map { (osString, timeInMs) ->
                            val os = Os.valueOf(osString.uppercase(Locale.US))

    /**
     * Puts the specified data into the cache. <strong>Warning:</strong> The cache will directly save the provided
     * reference. If the cached data is mutable, i.e. could be modified after being put into the cache, the caller is
     * responsible for creating a copy of the original data and store the copy in the cache.
     *
     * @param request The repository request from which this cache was retrieved, must not be {@code null}.

    }

    private static Stream<Map.Entry<AccessorKey, ReplacedAccessor>> oldRemovedAccessorsOfUpgradedProperty(UpgradedProperty upgradedProperty) {
        return upgradedProperty.getReplacedAccessors().stream()
            .filter(replacedAccessor -> replacedAccessor.getBinaryCompatibility() == ACCESSORS_REMOVED)
            .map(replacedAccessor -> {

		return false
	}
	for _, rule := range c.Rules {
		if rule.Status == Disabled {
			continue
		}
		if len(prefix) > 0 && len(rule.Filter.Prefix) > 0 {
			// incoming prefix must be in rule prefix
			if !recursive && !strings.HasPrefix(prefix, rule.Filter.Prefix) {
				continue
			}
			// If recursive, we can skip this rule if it doesn't match the tested prefix or level below prefix
			// does not match

 *
 * <p>Generally, implementations don't support {@link #put} and {@link #putAll} because there is no
 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *