@Override
    public boolean hasConflicts() {
        return !conflicts.isEmpty();
    }

    /**
     * Resolves the conflict by delegating to the conflict resolver who selects single version from given candidates. Executes provided action against the conflict resolution result object.
     */
    @Override
    public void resolveNextConflict(Action<ConflictResolutionResult> resolutionAction) {
        assert hasConflicts();

            ${snippets.imports}

            ${snippets.body}
        """

        buildFile("""
            plugins {
                id("test-convention-plugin")
            }
        """)

        executer.noDeprecationChecks()

        when:
        configurationCacheFails(":help")

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {

* **Starlette**:
    * Terá o melhor desempenho, depois do Uvicorn. Na verdade, o Starlette utiliza o Uvicorn para rodar. Portanto, ele pode ficar mais "devagar" que o Uvicorn apenas por ter que executar mais código.
    * Mas ele fornece as ferramentas para construir aplicações web simples, com roteamento baseado em caminhos, etc.

import org.gradle.internal.cc.impl.fixtures.ToolingApiBackedGradleExecuter
import org.gradle.internal.cc.impl.fixtures.ToolingApiSpec
import org.gradle.integtests.fixtures.executer.GradleExecuter

class ConfigurationCacheToolingApiInvocationIntegrationTest extends AbstractConfigurationCacheIntegrationTest implements ToolingApiSpec {
    @Override
    GradleExecuter createExecuter() {

            }
        """
    }

    @NoDebug
    def "fails appropriately if runner is loaded from a JAR that is not part of the distribution and no explicit version set"() {
        when:
        executer.withStackTraceChecksDisabled()
        def jarsDir = file('jars').createDir()

        new File(distribution.gradleHomeDir, 'lib').eachFileRecurse(FileType.FILES) { f ->
            if (f.name.contains("gradle-test-kit")

        outputDoesNotContain 'initscript1!'
        outputContains 'initscript2!'
        configurationCache.assertStateStored()
    }

    private File gradleUserHomeDirFile(String path) {
        executer.gradleUserHomeDir.file(path)
    }

                    }
                    ${outputStream}.println("Hello, " + name);
                }
            }
        """
    }

    def withStdInContents(String message) {
        executer.withStdinPipe(new PipedOutputStream() {
            @Override
            synchronized void connect(PipedInputStream snk) throws IOException {
                super.connect(snk)
                write(message.bytes)

    def apiJarVersion = System.getProperty("integTest.distZipVersion")
    def kotlinVersion = System.getProperty("integTest.kotlinVersion")

    def setup() {
        executer.beforeExecute {
            args("-Dorg.gradle.unsafe.suppress-gradle-api=true")
            withInstallations(jvm)
        }

        file("src/test/java/org/example/PublishedApiTestPluginTest.java") << pluginTestJava()

        }
    }

    private
    fun WriteContext.writeReference(value: Any?) {
        // Cannot warn about a script reference here, because we don't know whether the closure will attempt to use the script object when it executes,
        // and since almost every closure in a Groovy build script legitimately has the script as an owner, this will generate false problems.
        // So instead, warn when the script object is used by the closure when executing

                        println(name) // task property is ok
                        println(gradleVersion)
                    }
                }
            }
        """
        executer.beforeExecute { withArguments("-I", initScript.absolutePath) }

        when:
        configurationCacheFails ":some"

        then:
        failure.assertHasFileName("Initialization script '$initScript'")