// The reference may be from another file, so we need to allow all main test files
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

        // Package scope tests may collect symbols from multiple files, so we need to allow all main test files.
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toSet;

/**
 * Container for storing the request from the user to activate or deactivate certain projects and optionally fail the
 * build if those projects do not exist.
 */
public class ProjectActivation {

			},
			expected: []corev1.ResourceName{corev1.ResourceMemory, corev1.ResourceCPU},
		},
	}
	for testName, testCase := range testCases {
		actualSet := ToSet(ResourceNames(testCase.a))
		expectedSet := ToSet(testCase.expected)
		if !actualSet.Equal(expectedSet) {
			t.Errorf("%s expected: %v, actual: %v", testName, expectedSet, actualSet)
		}
	}
}

func TestContains(t *testing.T) {

        configureTask()
        test.include("include")
        test.exclude("exclude")
        def classFiles = test.getCandidateClassFiles()

        expect:
        assertIsDirectoryTree(classFiles, toSet("include"), toSet("exclude"))
    }

    def "disables parallel execution when in debug mode"() {
        given:
        configureTask()

        when:
        test.setDebug(true)

        val rootProperties = readProperties(rootPropertiesFile.asFile)
        val jvmArgs = listOf(buildLogicProperties, rootProperties).map { it.getProperty("org.gradle.jvmargs") }.toSet()
        if (jvmArgs.size > 1) {
            throw GradleException("gradle.properties and build-logic/gradle.properties have different org.gradle.jvmargs " +

    }

    @Override
    public Set<InstallationLocation> get() {
        if (os.isMacOsX()) {
            return javaHomeCommand.findJavaHomes().stream().map(this::asInstallation).collect(Collectors.toSet());
        }
        return Collections.emptySet();
    }

    private InstallationLocation asInstallation(File javaHome) {
        return InstallationLocation.autoDetected(javaHome, getSourceName());
    }

            include 'b'
        """

        when:
        def gradleBuild = withConnection {
            action(new FetchGradleBuild()).run()
        }
        then:
        gradleBuild.projects*.projectIdentifier.toSet().size() == 3
    }

    def "Applies BuildInvocations compatibility mapping"() {
        when:
        def buildInvocations = withConnection {
            action(new FetchBuildInvocations()).run()
        }

 * preferred.
 */
class RouteDatabase {
  private val _failedRoutes = mutableSetOf<Route>()

  val failedRoutes: Set<Route>
    @Synchronized get() = _failedRoutes.toSet()

  /** Records a failure connecting to [failedRoute]. */
  @Synchronized fun failed(failedRoute: Route) {
    _failedRoutes.add(failedRoute)
  }

  /** Records success connecting to [route]. */

        given:
        projectDir.file("include") << "bar"

        when:
        task.from projectDir.absolutePath
        task.include "include"

        then:
        task.mainSpec.getIncludes() == ["include"].toSet()
        task.mainSpec.buildRootResolver().source.files == task.project.fileTree(projectDir).files
    }

    static class TestCopyTask extends AbstractCopyTask {
        CopyAction copyAction