* MetaClass.getMetaProperty(name) is very expensive when the property is not known.
         * Instead, we reach into the meta class to call a much more efficient lookup method.
         * Since we do this in a hot code path, we also reuse the argument array used for the
         * reflective call to save memory.
         */
        @Nullable
        protected MetaProperty lookupProperty(MetaClass metaClass, String name) {

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()", "", ""],
        ]
    }

        outputDoesNotContain('Providing metadata for group:projectA:1.1')

        and: "remote status file parsed only once"
        outputContains 'Parsing status file call count: 1'
        outputDoesNotContain('Parsing status file call count: 2')

        when: "resolving the same dependencies"
        server.expectHead("/repo/status.txt", statusFile)

 * 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 {

        given:
        startIdleDaemon()
        assert !registry.all.empty

        connector.connector.connect(_ as Address) >> { throw new ConnectException("Problem!", new RuntimeException("foo")) }

        when:
        def connection = connector.maybeConnect( { true } as ExplainingSpec)

        then:
        !connection

        registry.all.empty
    }

class TaskSelectionIntegrationTest extends AbstractIntegrationSpec {

    @ToBeFixedForIsolatedProjects(because = "subprojects")
    def "given an unqualified name traverse project tree from current project and select all tasks with matching name"() {
        createDirs("a", "b", "a/a", "b/b")
        settingsFile << "include 'a', 'b', 'a:a', 'b:b'"

        buildFile << """
            subprojects {
                task thing

* A `File` — used as a file path
* A `FileCollection` or `FileTree` — all files in the collection are included in the copy
* A task — the files or directories that form a task's <<incremental_build.adoc#sec:task_inputs_outputs,defined outputs>> are included

    /**
     * Submits an arbitrary number of runnable operations, created synchronously by the scheduling action, to be executed in the global
     * build operation thread pool. Operations may execute concurrently. Blocks until all operations are complete.
     *
     * <p>Actions are not permitted to access any mutable project state. Generally, this is preferred.</p>
     */