}
        }

        task run(dependsOn: configurations.compile) {
            doLast {
                assert files*.listFiles().flatten().text == ['some text']
            }
        }
        '''

        when:
        run 'check'

        then:
        executed ':check'

        when:
        run 'run'

        then:
        executed ':run'
    }

    /**

fun test() {
    run {
        return@run/* <anonymous>@(2,9) */
    }
    run {
        return@test/* test@(1,1) */
    }
    run a@{
        return@a/* <anonymous>@(8,11) */
    }
    run {
        with("") {
            return@with/* <anonymous>@(12,18) */
            return@run/* <anonymous>@(11,9) */
            return@test/* test@(1,1) */
        }
    }
}

val i = a@{
    return@a/* <anonymous>@(20,11) */

        def mainClass = consumingModuleClass('moda.ModaClass')
        mainClass.text = mainClass.text.replace('.run()', '.run(); MainModule.class.getModule().getResourceAsStream("data.txt").readAllBytes()')
        file('src/main/resources/data.txt').text = "some data"

        when:
        succeeds ':run'

        then:
        outputContains("Module Name: consumer")
        outputContains("Module Version: 1.0-beta2")
    }

    fakePool.execute(
        new Runnable() {
          @Override
          public void run() {
            Thread.currentThread().interrupt();
          }
        });
    // Run a task that expects that it is not interrupted while it is running.
    e.execute(
        new Runnable() {
          @Override
          public void run() {
            assertThat(Thread.currentThread().isInterrupted()).isFalse();
          }

        then:
        0 * exitHandler.run()
        then:
        parser.name == "first"
        parser.relativePath == "first"
        !parser.root
        !outsideOfRoot

        when:
        outsideOfRoot = parser.nextPath("tree-some/first/file.txt", false, exitHandler)
        then:
        0 * exitHandler.run()
        then:
        parser.name == "file.txt"

            """
    }

    @ToBeFixedForConfigurationCache
    def "can run offline mode after hitting broken repo url"() {
        given:
        buildFileWithSnapshotDependency()
        and:
        noAuthorizationRepo()

        publishedMavenModule()
        when:
        moduleAvailableViaHttp()
        then:
        run 'retrieve'

        when:
        server.resetExpectations()

          sudo cp /var/run/secrets/istio/bootstrap/root-cert.pem /var/run/secrets/istio/root-cert.pem
          sudo cp /var/run/secrets/istio/bootstrap/*.env /var/lib/istio/envoy/
          sudo cp /var/run/secrets/istio/bootstrap/mesh.yaml /etc/istio/config/mesh

          # don't overwrite /etc/hosts since it's managed by kubeproxy
          #sudo sh -c 'cat /var/run/secrets/istio/bootstrap/hosts >> /etc/hosts'

        def failure = new RuntimeException()

        when:
        action.run()

        then:
        1 * resultProcessor.started(!null, !null)
        then:
        1 * processor.startProcessing(!null)
        then:
        1 * detector.run() >> { throw failure }
        then:
        1 * workerLeaseService.blocking(_) >> { Runnable runnable -> runnable.run() }
        1 * processor.stop()
        then:

        when:
        def builder = workerFactory.multiRequestWorker(StatefulTestWorker.class)
        def worker = builder.build()
        worker.start()
        def result1 = worker.run("value")
        def result2 = worker.run("value")
        def result3 = worker.run("value")
        worker.stop()

        then:
        result1 == "value:1"
        result2 == "value:2"
        result3 == "value:3"

        cleanup:

                        .addProgressListener(events)
                        .run()
        }

        then:
        events.assertIsABuild()

        def root = events.operation("Run build")
        root.descendant("Run init scripts")
    }

    def "generates buildSrc operation when there is a nested buildSrc build"() {
        when: