when:
        run('check')

        then:
        assertTestPassed("org.example.SomeThingPluginTest", "plugin registers task")
        assertFunctionalTestPassed("org.example.SomeThingPluginFunctionalTest", "can run task")

        when:
        run('check', '--rerun-tasks')

        then:
        assertTestPassed("org.example.SomeThingPluginTest", "plugin registers task")

            }
        """

        expect:
        2.times {
            run(":buildSrc:something")
            result.assertTaskExecuted(":buildSrc:something")
        }

        run(":buildSrc:jar")
        result.assertTaskExecuted(":buildSrc:jar")

        run(":buildSrc:jar")
        // Task will not run when configuration cache is enabled
    }

        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        executedAndNotSkipped(task)
    }

    void taskIsCached(String task) {
        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        skipped(task)
    }

        and:
        commonJvmFilesGenerated(scriptDsl)
        dslFixture.assertDoesNotUseTestSuites()

        when:
        run("build")

        then:
        assertTestPassed("org.example.AppTest", "appHasAGreeting")

        when:
        run("run")

        then:
        outputContains("Hello World!")

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }

        target.createFile()
        run 'producesLink'
        then:
        executedAndNotSkipped ':producesLink'

        when:
        run 'producesLink'
        then:
        skipped ':producesLink'

        when:
        target.delete()
        run 'producesLink'
        then:
        executedAndNotSkipped ':producesLink'

        when:
        run 'producesLink'
        then:

            apply plugin: 'java'

            task run(type: JavaExec) {
                dependsOn 'compileJava'
                classpath = sourceSets.main.runtimeClasspath
                mainClass = 'Main'
            }
        """

        when:
        executer.withConsole(consoleType)
        succeeds("run")

        then:
        def output = result.groupedOutput.task(':run').output
        output.contains(EXPECTED_OUTPUT)

        run: python -m build --sdist
      - name: Decompress source distribution
        run: |
          cd dist
          tar xvf fastapi*.tar.gz
      - name: Install test dependencies
        run: |
          cd dist/fastapi*/
          pip install -r requirements-tests.txt
        env:
          TIANGOLO_BUILD_PACKAGE: ${{ matrix.package }}
      - name: Run source distribution tests
        run: |

            }

            tasks.register("run", JavaExec) {
                javaLauncher = javaToolchains.launcherFor {
                    languageVersion = JavaLanguageVersion.of(${jdk.javaVersion.majorVersion})
                }
                setJvmArgs(['-version'])
                mainClass = 'None'
            }
        """

        when:
        withInstallations(jdk).run(":run", "--info")

        then:

        when:
        run(":api:build")

        then:
        fixture.assertProjectsConfigured(":", ":api")

        when:
        inDirectory("impl")
        run(":api:build")

        then:
        fixture.assertProjectsConfigured(":", ":api")

        when:
        run(":impl:build")

        then:

        """

        expect:
        blockingServer.expectConcurrent("a", "b")

        run ":a:ping", ":b:ping"

        and:
        blockingServer.expectConcurrent("a", "b")

        run ":a:ping", ":b:ping"
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "tasks are not run in parallel when they require an exclusive shared service"() {
        given:
        withParallelThreads(2)