}
}


class LazyEnvironmentVariable(private val callable: Callable<String>) {
    override fun toString(): String {
        return callable.call()
    }
}


private
fun Project.loadScenariosFromFile(testProject: String): List<String> {
    val scenarioFile = repoRoot().file("performance-test-splits/include-$testProject-performance-scenarios.csv").asFile

`--single-path` (optional)::
Render only a single path to the dependency.
`--all-variants` (optional)::
Render information about all variants, not only the selected variant.

The following code snippet demonstrates how to run a dependency insight report for all paths to a dependency named "commons-codec" within the "scm" configuration:

----

A component metadata rule can be applied to all modules — `all(rule)` — or to a selected module — `withModule(groupAndName, rule)`.
Usually, a rule is specifically written to enrich metadata of one specific module and hence the `withModule` API should be preferred.

    def "unfriendly behavior of command line parsing"() {
        when:
        run '-all'

        then:
        "should fail with a decent error, not internal error (applies to all CommandLineArgumentExceptions)"
        "should complain that there's no '-all' option"

        when:
        run 'tasks', '-refresh-dependencies'

        then:

            }

            task foo {
                dependsOn tasks.withType(Zip)
                doLast {
                    assert defaultTaskRealizedCount == 0, "All DefaultTask shouldn't be realized"
                    assert zipTaskRealizedCount == 1, "All Zip task should be realized"
                }
            }
        '''

        expect:
        succeeds "foo"
    }

        return buildOperationRunner.call(new CallableBuildOperation<Task>() {
            @Override
            public BuildOperationDescriptor.Builder description() {
                return realizeDescriptor(identity, replace, true);
            }

            @Override
            public Task call(BuildOperationContext context) {
                try {

import spock.lang.Ignore

import java.lang.annotation.ElementType
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target

/**
 * Make sure all feature methods are annotated by {@link @RunFor}
 *
 * @see {@link @RunFor}
 */
@Target([ElementType.TYPE])
@Retention(RetentionPolicy.RUNTIME)
@ExtensionAnnotation(AllFeaturesShouldBeAnnotatedByRunForExtension.class)

            [fromStringArray(), "command.execute()", "", ""],
            [fromStringList(), "command.execute()", "", ""],
            [fromObjectList(), "command.execute()", "", ""],
            // null-safe call
            [fromGroovyString(), "command?.execute()", "", ""],
        ]
    }

 * limitations under the License.
 */

package org.gradle.declarative.dsl.evaluation

import java.io.Serializable


/**
 * Represents the "generation" of a particular operation (either an addition function call or a property assignment operation).
 *
 * The order of generations is important as calls in later generations can override calls in earlier generations, but no the
 * other way around.

        }

        then:
        out.toString().contains("<${["var": "val"]}>")
    }

    @TargetGradleVersion(">=4.11")
    def "new Gradle versions can mutate environment on all JDK versions"() {
        given:
        toolingApi.requireDaemons() //cannot be run in embedded mode

        buildFile << """
            task printEnv() {
                doLast {