given:
        file("settings.gradle") << 'rootProject.name="hello-world"'

        when:
        CustomModel customModel = withConnection { it.action(new FetchCustomModel()).run() }

        then:
        customModel.gradle.name == "hello-world"
        customModel.eclipse.gradleProject.name == "hello-world"

        when:
        IdeaProject ideaModel = withConnection { it.action(new FetchIdeaModel()).run() }

        """
    }

    def "Appends additional JVM arguments"() {
        when:
        BuildEnvironment env1 = loadBuildEnvironment { builder -> builder.addJvmArguments(JVM_ARG_1) }

        then:
        env1.java.jvmArguments.contains(JVM_ARG_1)

        when:
        BuildEnvironment env2 = loadBuildEnvironment { builder -> builder.addJvmArguments([JVM_ARG_1]) }

        then:

                    outputFile.text = "Hello world"
                }
            }
        """

        when:
        withWatchFs().run "myTask"
        then:
        executedAndNotSkipped ":myTask"

        when:
        withWatchFs().run "myTask"
        then:
        skipped(":myTask")

        when:
        file(fileToChange).text = "changed"
        waitForChangesToBePickedUp()
        withWatchFs().run "myTask"

        0 * _

        when:
        result = cache.get(file)

        then:
        result == 12
        0 * _
    }

    def "calculates entry value for directory when not seen before and reuses result"() {
        def file = new File("thing.txt")
        def cache = factory.newCache("cache", 12000, calculator, BaseSerializerFactory.INTEGER_SERIALIZER)

        when:
        def result = cache.get(file)

    def "eagerly locates task with given name for single project"() {
        def task = task('task')

        when:
        def candidates = resolver.selectWithName('task', project, false)

        then:
        1 * tasks.discoverTasks()
        1 * tasks.names >> (['task'] as SortedSet)
        0 * tasks._

        when:
        def matches = asTasks(candidates)

        then:
        matches == [task]

        and:

        given:
        cacheOpened()

        when:
        cache.finishWork()

        then:
        1 * fileAccess.writeFile(!null) >> { Runnable action -> action.run() }
        1 * backingCache.close()
        0 * _._
    }

    def "closes cache when closed"() {
        given:
        cacheOpened()

        when:
        cache.finishWork()

        then:

            }
            """

        when:
        run "thing"

        then:
        result.assertTasksExecuted(":a:thing", ":b:thing", ":a:a:thing", ":b:b:thing")

        when:
        executer.inDirectory(file("a"))
        run "thing"

        then:
        result.assertTasksExecuted(":a:thing", ":a:a:thing")

        // camel case matching
        when:
        run "th"

        then:

    }

    def "When execute updateDaemonJvm without options Then build properties are populated with default values"() {
        when:
        run "updateDaemonJvm"

        then:
        assertJvmCriteria(Jvm.current().javaVersion)
        outputContains("Daemon JVM criteria is an incubating feature.")
    }

        source.add("fizz")

        when:
        def iterator = source.iteratorNoFlush()
        iterator.remove()

        then:
        thrown(IllegalStateException)

        when:
        def next = iterator.next()

        then:
        next == "foo"

        when:
        iterator.remove()

        then:

        when:
        run("other")

        then:
        result.assertNotOutput("task1")
        result.assertNotOutput("task2")

        when:
        run("task2")

        then:
        outputContains("Create :task1")
        outputContains("Configure :task1")
        outputContains("Create :task2")
        outputContains("Configure :task2")
    }