// Note that all tests use a relative path to the script because its absolute path may contain
    // spaces and it breaks logic String.execute which splits the given string at spaces without
    // any options to escape the space.
    ShellScript baseScript = ShellScript.builder().printEnvironmentVariable('FOOBAR').printWorkingDir().writeTo(testDirectory, "test")

    def setup() {

        projectName.set(project.name)
    }

    private boolean containsSpecialVersions() {
        return baselines.getOrElse("")
            .split(",")
            .collect { it.toString().trim() }
            .any { NON_CACHEABLE_VERSIONS.contains(it) }
    }

    private boolean isFlakinessDetection() {
        return channel.startsWith("flakiness-detection")

        and:
        configurationCacheRun "myTask"

        then:
        outputContains("foo")
        configurationCache.assertStateLoaded()

        when:
        def commandLineArgs = commandLine.split("\\s+")
        executer.withArguments(commandLineArgs)
        configurationCacheRun "myTask"

        then:
        outputContains("bar")

        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """
        // Intentionally don't apply to project b. Should split this case (some projects don't have the model available) out into a separate test

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProject())

    }

    enum DynamicVersionScenario {
        SINGLE_REPO, MATCHING_REPO_PLUS_404

        @Override
        String toString() {
            super.toString().split('_').collect { it.toLowerCase() }.join(' ')
        }
    }

    private static String repositoriesBlockFor(List<RepoFixture> fixtures) {
        """
            repositories {

        "<ul><li><ul><li>text<li>text"            | "<ul><li><ul><li>text</li><li>text</li></ul></li></ul>"
    }

    def "splits para on block content"() {
        expect:
        parse(source) == transformed

        where:
        source                      | transformed

            .collect { it.trim() }
            .grep { !it.isEmpty() }
    }

    static List<String> parentCommitsOf(String commit) {
        return getStdout("git show --format=%P --no-patch $commit")
            .split(" ").collect { it.trim() }.grep { !it.isEmpty() }
    }

    @groovy.transform.ToString
    static class ExecResult {
        String stdout
        String stderr
        int returnCode
    }

        def blocksTable = withCategories { blocksSection ? blocksSection.table[0] : parse('<table/>') }
        _ * classDoc.simpleName >> name.split('\\.').last()
        _ * classDoc.name >> name
        _ * classDoc.id >> (args.id ?: name)
        _ * classDoc.classSection >> content
        _ * classDoc.propertiesSection >> propertiesSection

    }

    private void assertModelsQueried(HasIntermediateDetails details) {
        def models = modelRequests().toSorted { it.buildTreePath }
        def (buildScopedModels, projectScopedModels) = models.split { it.buildScoped }
        assert buildScopedModels.size() == details.buildModelQueries

        // Count of 0 is a special case used by `modelsQueriedAndNotPresent`

 */

package gradlebuild.performance.generator
/**
 * Generates project dependencies for generated test projects used in performance tests
 *
 * In order to generate realistic project dependencies, we split the projects to layers and generate
 * dependencies to projects in lower layers. The sizes of different layers are created so that
 * the first and last layers are the smallest and the layers in the middle are the largest.
 *