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

    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:

    }

    def "fails on non-static inner class when outer type not provided as first parameter when type takes constructor params"() {
        given:
        services.find(Number) >> 12

        when:
        def inst = instantiator.newInstance(NonStaticWithParams, this, "param")

        then:
        inst.owner == this

        when:
        instantiator.newInstance(NonStaticWithParams, "param")

        inputs.sourceFiles.empty
    }

    def "can register input file"() {
        when:
        inputs.file("a")
        then:
        inputFileProperties() == ['$1': "a"]
        inputs.files.files == files("a")
    }

    def "can register input file with property name"() {
        when:
        inputs.file("a").withPropertyName("prop")
        then:
        inputFileProperties() == ['prop': "a"]

    into 'libs'
    from configurations.compile
}
"""
        and:
        module.allowAll()

        when:
        succeeds 'retrieve'

        then:
        file('libs').assertHasDescendants('projectA-1.2.jar')
        def snapshot = file('libs/projectA-1.2.jar').snapshot()

        when:
        module.publishWithChangedContent()

        and:
        server.resetExpectations()

        e == failure
    }

    def "cannot get file when no result specified"() {
        when:
        result.result

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

    def "cannot get failure when no result specified"() {
        when:
        result.failure

        then:
        IllegalStateException e = thrown()

            }
        """

        when:
        succeeds "copy"
        then:
        executedAndNotSkipped(":copy")

        file('build/input.txt').makeOlder()

        when:
        succeeds "copy"
        then:
        skipped ":copy"

        buildFile << """
            task other {}
        """

        when:
        succeeds "copy"
        then:
        skipped ":copy"