corev1.ResourceServicesNodePorts,
		corev1.ResourceServicesLoadBalancers,
	}
	// but we only match these...
	expected := quota.ToSet([]corev1.ResourceName{
		corev1.ResourceServices,
		corev1.ResourceServicesNodePorts,
		corev1.ResourceServicesLoadBalancers,
	})
	actual := quota.ToSet(evaluator.MatchingResources(input))
	if !expected.Equal(actual) {
		t.Errorf("expected: %v, actual: %v", expected, actual)
	}
}

                        d.getGroupId() + ":" + d.getArtifactId()))
                .map(Artifact::getVersion)
                .collect(Collectors.toSet());

        if (mavenVersions.size() > 1) {
            pluginValidationManager.reportPluginValidationIssue(
                    PluginValidationManager.IssueLocality.EXTERNAL,
                    session,

	zero := resource.MustParse("0")
	for k, v := range a {
		if v.Cmp(zero) < 0 {
			results = append(results, k)
		}
	}
	return results
}

// ToSet takes a list of resource names and converts to a string set
func ToSet(resourceNames []corev1.ResourceName) sets.String {
	result := sets.NewString()
	for _, resourceName := range resourceNames {
		result.Insert(string(resourceName))
	}
	return result

                .filter { it.name.endsWith(".class") }
                .map { entry ->
                    entry.name.substring(0, name.lastIndexOf('/')).replace('/', '.')
                }
                .collect(Collectors.toSet())
        }
    }
// tag::artifact-transform-relocate[]
}
// end::artifact-transform-relocate[]

configurations.create("externalClasspath")

def usage = Attribute.of('usage', String)

        return project.getExtensions().getByType(ReportingExtension.class).file(projectReportDirName);
    }

    @Override
    public Set<Project> getProjects() {
        logDeprecation();
        return WrapUtil.toSet(project);
    }

    private static void logDeprecation() {
        DeprecationLogger.deprecateType(org.gradle.api.plugins.ProjectReportsPluginConvention.class)
            .willBeRemovedInGradle9()

                        d.getGroupId() + ":" + d.getArtifactId()))
                .map(Artifact::getVersion)
                .filter(v -> v.startsWith("2."))
                .collect(Collectors.toSet());

        if (!maven2Versions.isEmpty()) {
            pluginValidationManager.reportPluginValidationIssue(
                    PluginValidationManager.IssueLocality.EXTERNAL,
                    session,

            return sourcePaths;
        }

        Set<String> paths = fileExtensions.stream()
            .map(fileExtension -> classNameToRelativePath(className, fileExtension))
            .collect(Collectors.toSet());

        // Classes with $ may be inner classes
        int innerClassIdx = className.indexOf("$");
        if (innerClassIdx > 0) {
            String baseName = className.substring(0, innerClassIdx);

                        .map(execution -> flakinessDataProvider.getScenarioRegressionResult(scenario.getPerformanceExperiment(), execution))
                        .collect(Collectors.toSet());
                    if (regressionResults.contains(STABLE_REGRESSION)) {
                        failureCollector.scenarioRegressed();

        if (configuration.isAutoDetectEnabled() || configuration.isDownloadEnabled()) {
            return cacheDirProvider.listJavaHomes().stream()
                .map(this::asInstallation)
                .collect(Collectors.toSet());
        } else {
            return Collections.emptySet();
        }
    }

    private InstallationLocation asInstallation(File javaHome) {

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
import static java.util.stream.StreamSupport.stream;
import static org.gradle.util.internal.GroovyDependencyUtil.groovyModuleDependency;

/**