}
            tasks.register("mytask", MyTask) {
                conventionMapping.map("foo") { bar }
                bar.setFrom("file1", "file2")
            }
        """

        expect:
        succeeds 'mytask'
    }

    def "convention mapping works with FileCollection in a ConventionTask"() {
        buildFile << """
            abstract class MyTask extends org.gradle.api.internal.ConventionTask {

        buildFile << script

        when:
        fails 'myTask'

        then:
        failure.assertHasCause("Could not create task ':myTask'.")

        where:
        position | script
        1        | "tasks.register('myTask', CustomTask, null, 1)"
        2        | "tasks.register('myTask', CustomTask, 'abc', null)"
    }

        """
        buildFile << """
            class MyTask extends DefaultTask {
                @TaskAction
                void doIt() {
                    for (Project subproject : project.rootProject.getAllprojects()) {
                        for (MyTask myTask : subproject.tasks.withType(MyTask)) {
                            println "Looking at " + myTask.path
                        }
                    }

                    assert foo.get() == "foobar"
                }
            }
            tasks.register("mytask", MyTask) {
                conventionMapping.map("foo", { providerFactory.provider { "foobar" } })
                other.convention("other")
            }
        """

        expect:
        runAndFail 'mytask'
        expectDocumentedFailure()
    }

                }
            }

            tasks.register("myTask", MyTask) {
                inputFile.set(createArchive.flatMap { it.outputFile })
                outputFile.set(layout.buildDirectory.file("unpacked/file.txt"))
            }
        """

        when:
        run "myTask"

        then:
        file("build/unpacked/file.txt").isFile()

        where:

        buildFile << """
            task myTask(type: MyTask) {
                conventionMapping.someProperty = {"Foo"}
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {
            myTask.text = myTask.text.replace("runAction$i", "runAction${i + 1}")
            executer.withBuildJvmOpts("-Xmx256m", "-XX:+HeapDumpOnOutOfMemoryError")
            assert succeeds("myTask")
        }
    }

dependencies {
    sharedConfig generateConfigZip.outputs.files
}

task stringText(type: MyTask) {
    config = resources.text.fromString("my config")
    output = project.file("output.txt")
}

task fileText(type: MyTask) {
    config = resources.text.fromFile("config.txt")
    output = project.file("output.txt")
}

task fileCollectionText(type: MyTask) {
    config = resources.text.fromFile(generateConfigFile.get())

            $beforeProject {
                it.tasks.register("myTask") {
                }
            }
        """
        createDir 'sub'

        and:
        buildFile '''
            subprojects {
                tasks.named("myTask") {
                    def projectName = project.name
                    doLast {
                        println "${projectName}.MyTask.doLast is running"
                    }
                }

        given:
        buildFile << """
            abstract class MyTask extends DefaultTask {

                @Input abstract Property<String> getMessage()

                @TaskAction def action() {
                    println(message.get())
                }
            }
            tasks.register("myTask", MyTask) {
                // use an undeclared input so we can test --refresh-dependencies

            }

            task myTask(type: MyTask) {
                conventionMapping('archiveName') { 'not something' }
                archiveFileName.convention("something")
            }
        """

        expect: 'convention mapping is ignored'
        configurationCacheRun 'myTask'

        and: 'convention mapping is ignored just the same'
        configurationCacheRun 'myTask'
    }