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))
    }

        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 =

                val answer = computer.compute()
                println("*" + answer + "*")
                """
            )

        assert(
            build("-I", initScript.canonicalPath)
                .output.contains("*42*")
        )
    }

    @Test
    fun `initscript file path is resolved relative to parent script dir`() {

        val initScript =
            withFile(
                "gradle/init.gradle.kts",

        }
        skipConditionally(buildType)
    }

fun Requirements.requiresOs(os: Os) {
    contains("teamcity.agent.jvm.os.name", os.agentRequirement)
}

fun Requirements.requiresArch(os: Os, arch: Arch) {
    if (os == Os.MACOS) {
        contains("teamcity.agent.jvm.os.arch", arch.nameOnMac)
    } else {
        contains("teamcity.agent.jvm.os.arch", arch.nameOnLinuxWindows)
    }
}

        return Project::class
            .memberFunctions
            .asSequence()
            .mapNotNull { it.javaMethod }
            .filterNot { objectMethods.contains(it) }
            .map { it.toGroovyScriptString() }
            .sorted()
            .joinToString(separator = "\n")
    }

    private
    fun Method.toGroovyScriptString(): String {

    override fun shouldInclude(taskPath: String): Boolean {
        // https://github.com/gradle/gradle/issues/21351
        return super.shouldInclude(taskPath) || taskPath.contains("ktlintMainSourceSetCheck")
    }

    override fun action(taskPath: String, taskResult: TaskOperationResult) {
        if (taskResult is TaskFailureResult) {
            failedTaskPaths.add(taskPath)
        }
    }

internal
enum class StateType(val encryptable: Boolean = false) {
    /**
     * Contains the state for the entire build.
     */
    Work(true),

    /**
     * Contains the side effects observed during the creation of the [Model].
     */
    ModelSideEffects(true),

    /**
     * Contains the model objects sent back to the IDE in response to a TAPI request.
     */
    Model(true),

 */
abstract class NamedDomainObjectContainerDelegate<T : Any> : NamedDomainObjectContainer<T> {

    internal
    abstract val delegate: NamedDomainObjectContainer<T>

    override fun contains(element: T): Boolean =
        delegate.contains(element)

    override fun addAll(elements: Collection<T>): Boolean =
        delegate.addAll(elements)

    override fun named(predicate: Spec<String>): NamedDomainObjectSet<T> =

    override fun shouldVisitMethod(node: MethodNode): Boolean = isIntegrationTest(node.declaringClass)

    override fun visitMethodCallExpression(mce: MethodCallExpression) {
        if (AstUtil.isMethodNamed(mce, "contains")) {
            checkOutputContains(mce)
        } else if (AstUtil.isMethodNamed(mce, "assertOutputContains")) {
            val objectExpr = mce.objectExpression
            checkIndirectOutputContains(objectExpr, mce)

 */
val Project.isPromotionBuild: Boolean
    get() {
        val taskNames = gradle.startParameter.taskNames
        return taskNames.contains("promotionBuild") ||
            // :updateReleasedVersionsToLatestNightly and :updateReleasedVersions
            taskNames.any { it.contains("updateReleasedVersions") }
    }


/**