task customFileTask {
                ext.outputFile = file('customFile-1.0-docs.html')
                def outputFile = ext.outputFile
                doLast {
                    outputFile << '<html/>'
                }
            }

            task regularFileTask {
                ext.outputFile = project.objects.fileProperty()
                outputs.file(outputFile)

                    outputs.file outputFile
                    doLast {
                        outputFile.parentFile.mkdirs()
                        outputFile.text = inputFile.text
                    }
                }
            """
        }

        settingsFile << """
            rootProject.name = "root"
            includeBuild "included"
        """

        buildFile << """
            task composite {

 * limitations under the License.
 */

// tag::verification-failure[]
val process = tasks.register("process") {
    val outputFile = layout.buildDirectory.file("processed.log")
    outputs.files(outputFile) // <1>

    doLast {
        val logFile = outputFile.get().asFile
        logFile.appendText("Step 1 Complete.") // <2>
        throw VerificationException("Process failed!") // <3>

import org.gradle.api.services.ServiceReference;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.TaskAction;

import java.net.URI;

public abstract class Download extends DefaultTask {
    // This property provides access to the service instance
    @ServiceReference("web")
    abstract Property<WebServer> getServer();

    @OutputFile
    abstract RegularFileProperty getOutputFile();

    @TaskAction

                FileCollection sources

                @OutputFile
                File outputFile

                public TaskWithInputs() {
                    sources = project.files()
                }

                @TaskAction
                void doSomething() {
                    outputFile.withWriter { writer ->
                        sources.each { writer.println it }

     */
    @OutputFile
    public RegularFileProperty getOutputFile() {
        return outputFile;
    }

    /**
     * The file where the linked binary will be located.
     *
     * @since 4.5
     */
    @Internal
    public RegularFileProperty getBinaryFile() {
        return this.outputFile;
    }

    /**

                @InputFile
                File inputFile = project.file("input.txt")

                @OutputFile
                File outputFile = new File(project.buildDir, "output.txt")

                @TaskAction
                void generate() {
                    outputFile.text = inputFile.text
                }
            }

        grandChildProject = TestUtil.createChildProject(childProject, "grandChild", new File("."))
    }

    def "moduleName controls outputFile"() {
        given:
        applyPluginToProjects()
        assert childProject.idea.module.name == "child"
        def existingOutputFolder = childProject.ideaModule.outputFile.parentFile

        when:
        childProject.idea.module.name = "foo"

        then:

        <configuration>
          <outputFile>test.properties</outputFile>
        </configuration>
        <executions>
          <execution>
            <id>test</id>
            <phase>validate</phase>
            <goals>
              <goal>eval</goal>
            </goals>
            <configuration>
              <outputFile>pom.properties</outputFile>
            </configuration>
          </execution>

        then:
        outputs.files.files == files('a')
        outputs.fileProperties*.propertyName == ['$1']
        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a")]
        outputs.fileProperties*.outputFile == [file("a")]
        outputs.fileProperties*.outputType == [FILE]
    }

    def "can register output file with property name"() {
        when:
        outputs.file("a").withPropertyName("prop")
        then: