"""
            public abstract class FakeResolverPlugin implements Plugin<Settings> {
                @Inject
                protected abstract JavaToolchainResolverRegistry getToolchainResolverRegistry();

                void apply(Settings settings) {
                    settings.getPlugins().apply("jvm-toolchain-management");

        settingsFile << """
            includeBuild("child1")
        """
        file("child1/settings.gradle") << """
            includeBuild("../child2")
        """
        file("child2/settings.gradle") << """
            includeBuild("../child1")
        """

        given:
        def model = withConnection {
            it.getModel(GradleBuild)

        """
        createDirs("buildSrc/one", "buildSrc/two")
        file("buildSrc/settings.gradle") << """
            include 'one'
            include 'two'
        """
        FeaturePreviewsFixture.enableTypeSafeProjectAccessors(file("buildSrc/settings.gradle"))
        createDirs("one", "two")
        settingsFile << """
            include 'one'
            include 'two'

org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configuration-cache=true
systemProp.gradle.publish.skip.namespace.check=true
# Kotlin DSL settings
org.gradle.kotlin.dsl.allWarningsAsErrors=true
# Kotlin settings
kotlin.incremental.useClasspathSnapshot=true
kotlin.stdlib.default.dependency=false
kotlin.js.ir.output.granularity=whole-program
# Temporarily force IDEs to produce build scans

 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.evaluator

import org.gradle.api.Project
import org.gradle.api.initialization.Settings
import org.gradle.api.internal.SettingsInternal
import org.gradle.api.internal.initialization.ClassLoaderScope
import org.gradle.declarative.dsl.evaluation.InterpretationSequence
import org.gradle.groovy.scripts.ScriptSource

 * limitations under the License.
 */

package org.gradle.plugin.software.internal;

import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.initialization.Settings;

import java.util.List;

/**
 * Represents a resolved software type implementation including the public model type and the plugin that exposes it.
 */
public interface SoftwareTypeImplementation<T> {

        """
        file('module-a').mkdir()
        file('module-b').mkdir()
        file('module-c').mkdir()
        file('module-a/settings.gradle') << """
            includeBuild('../module-b')
        """
        file('module-b/settings.gradle') << """
            includeBuild('../module-a')
        """
    }

    def "can find a build for of included build project despite cyclic include"() {

@TargetGradleVersion(">=7.3")
class DeferredConfigurationCrossVersionSpec extends ToolingApiSpecification {
    final String prefix = "-> configure"
    final String settingsMessage = "$prefix settings"
    final String rootProjectMessage = "$prefix root project"

    def "does not configure build when action does not query any models"() {
        setupBuild()

        when:
        def model = withConnection {

class UndeclaredBuildInputsKotlinSettingsScriptIntegrationTest extends AbstractUndeclaredBuildInputsIntegrationTest implements KotlinPluginImplementation {
    @Override
    String getLocation() {
        return "Settings file 'settings.gradle.kts'"
    }

    @Override
    void buildLogicApplication(BuildInputRead read) {
        settingsKotlinFile << """
            ${read.requiredImports().collect { "import $it" }.join("\n")}

	EnvCycle         = "MINIO_SCANNER_CYCLE"
	EnvDelayLegacy   = "MINIO_CRAWLER_DELAY"
	EnvMaxWait       = "MINIO_SCANNER_MAX_WAIT"
	EnvMaxWaitLegacy = "MINIO_CRAWLER_MAX_WAIT"
)

// Config represents the heal settings.
type Config struct {
	// Delay is the sleep multiplier.
	Delay float64 `json:"delay"`

	// Sleep always or based on incoming S3 requests.
	IdleMode int32 // 0 => on, 1 => off