class CircularReferences {

    private
    val refs = ReferenceOpenHashSet<Any>()

    fun enter(reference: Any) {
        require(refs.add(reference))
    }

    operator fun contains(reference: Any) =
        refs.contains(reference)

    fun leave(reference: Any) {
        require(refs.remove(reference))
    }

    }
    thing(Thing)
    thing {
        number "12"
        file "build.gradle"
    }
}
'''

        when:
        run "show"

        then:
        output.contains("t.number: 12")
        output.contains("t.file: ${buildFile}")
    }

    def "cannot configure a reference property using nested closure"() {
        buildFile << '''
@Managed interface Person extends Named {
    Address getAddress()

        KotlinDslModelsParameters.CORRELATION_ID_GRADLE_PROPERTY_NAME // Changing by IDE
    )

    fun isIgnoredStartParameterProperty(key: String): Boolean =
        ignoredStartParameterProperties.contains(key)


    fun canReadSystemProperty(from: String): Boolean =
        withWorkaroundsFor("systemProps") {
            isBuildScanPlugin(from)
        }

    fun canReadEnvironmentVariable(from: String): Boolean =

                        }
                    }
                }
            }

            apply type: RulePlugin
        '''

        then:
        succeeds "echo"

        and:
        output.contains("name: parent")
    }

    def "managed types can have cyclical managed type references where more than two types constitute the cycle"() {
        when:
        buildScript '''
            @Managed

        super(taskDependencyFactory);
    }

    public CompositeFileCollection() {
    }

    @Override
    public boolean contains(File file) {
        for (FileCollection collection : getSourceCollections()) {
            if (collection.contains(file)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean isEmpty() {

                void apply(Project project) {}
            }
            apply type: MultipleRuleSources
        '''

        then:
        succeeds "echo"

        and:
        output.contains "mutations: a, b"
    }

    def "mutation rules are executed in a fixed and arbitrary order"() {
        when:
        buildFile << '''
            class FirstSource extends RuleSource {
                @Mutate

    }

    @Override
    public Set<File> getFiles() {
        return CollectionUtils.filter(collection, new LinkedHashSet<>(), filterSpec);
    }

    @Override
    public boolean contains(File file) {
        return collection.contains(file) && filterSpec.isSatisfiedBy(file);
    }

    @Override
    public Iterator<File> iterator() {
        return Iterators.filter(collection.iterator(), filterSpec::isSatisfiedBy);
    }

        def sourceFile = file("src/main/java/MyClass.java")
        sourceFile.text = "public class MyClass { }"

        when:
        // We do a warmup run so even on Windows, the VFS really contains all the files we expect it to contain.
        withWatchFs().run("assemble")
        waitForChangesToBePickedUp()
        def vfsLogs = enableVerboseVfsLogs()
        withWatchFs().run("assemble")
        then:

        withWatchFs().run "jar", "-Dcreator=first"
        then:
        file("build/tmp/jar/MANIFEST.MF").text.contains("first")
        executedAndNotSkipped(":jar")

        when:
        withWatchFs().run "jar", "-Dcreator=second"
        then:
        file("build/tmp/jar/MANIFEST.MF").text.contains("second")
        executedAndNotSkipped(":jar")
    }

    def "detects when local state is removed"() {

        return commitBaseline(forkPointCommit)
    }

    private
    fun tryGetUpstream(): String? = project.execAndGetStdout("git", "remote", "-v")
        .lines()
        .find { it.contains("******@****.***:gradle/gradle.git") || it.contains("https://github.com/gradle/gradle.git") }
        .let {
            // origin	https://github.com/gradle/gradle.git (fetch)
            val str = it?.replace(Regex("\\s+"), " ")