}

    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"

            """
        }

        when:
        configurationCacheRun 'tasks', '-I', initScript.absolutePath

        then:
        outputContains 'foo!'
        configurationCache.assertStateStored()
        problems.assertResultHasProblems(result) {
            withInput("Initialization script 'initscript.gradle': file 'input.txt'")
        }

        when:
        buildLogicInput.text = 'bar!'

        and:

    }

    def "executable is unavailable when not found in system path"() {
        def visitor = Mock(DiagnosticsVisitor)

        given:
        os.getExecutableName("cc") >> "cc.bin"
        os.path >> []

        when:
        def result = registry.locate(ToolType.C_COMPILER, "cc")

        then:
        !result.available

        when:
        result.explain(visitor)

        then:

        def fileInWatchableHierarchies = file("first/inside/root/dir/file.txt")
        def fileOutsideOfWatchableHierarchies = file("forth").file("someFile.txt")

        when:
        registerWatchableHierarchies(watchableHierarchies)
        then:
        0 * _

        when:
        fileInWatchableHierarchies.createFile()
        addSnapshot(snapshotRegularFile(fileInWatchableHierarchies))
        then:

    def "validate name"() {
        when:
        ModelPath.validateName("")

        then:
        def e = thrown(ModelPath.InvalidNameException)
        e.message =~ "empty string"

        when:
        ModelPath.validateName("ü")

        then:
        e = thrown(ModelPath.InvalidNameException)
        e.message =~ "first character"

        when:
        ModelPath.validateName(" ")

        then:
        1 * delegate.stop()
        0 * _._
    }

    def 'does nothing on end of processing when no tests received'() {
        expect:
        processor.stop()
    }

    def 'does nothing on end of processing when on nth test'() {
        when:
        processor.startProcessing(resultProcessor)
        processor.processTestClass(test1)
        processor.processTestClass(test2)