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:

        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.")
    }

    def 'initialises when there is lock state'() {
        when:
        visitor.start(rootNode)

        then:
        1 * dependencyLockingProvider.loadLockState(lockId, _) >> lockState
        1 * lockState.mustValidateLockState() >> true
        1 * lockState.lockedDependencies >> emptySet()
        0 * _
    }

    def 'initialises when there is no lock state'() {
        when:

        when:
        fallback.attribute(one, "fallback")

        then:
        joined.keySet() == [one] as Set

        when:
        primary.attributeProvider(one, Providers.of("primary"))

        then:
        joined.keySet() == [one] as Set

        when:
        fallback.attributeProvider(two, Providers.of("fallback"))

        rules.setMutationValidator(checker)

        when: rules.all(Actions.doNothing())
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(Closure.IDENTITY)
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(ruleSource)
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.withModule("something:else", Actions.doNothing())

        result.graphState == graphState
    }

    def "cannot get id when no result has been specified"() {
        when:
        result.moduleVersionId

        then:
        IllegalStateException e = thrown()
        e.message == 'No result has been specified.'
    }

    def "cannot get state when no result has been specified"() {
        when:
        result.state

        then: