* Installation directory of the build-builder tool.
     */
    @PathSensitive(PathSensitivity.RELATIVE)
    @InputDirectory
    final DirectoryProperty buildBuilderInstall

    /**
     * Output directory for the generated project
     */
    @OutputDirectory
    final DirectoryProperty generatedDir

    /**
     * Additional arguments to provide to the build-builder.
     *

                DirectoryProperty result = project.getObjects().directoryProperty();
                result.set(project.file(baseDir));
                return result.get();
            }
        }));
    }

    /**
     * Returns base directory property to use for all reports.
     *
     * @since 4.4
     */
    public DirectoryProperty getBaseDirectory() {
        return baseDirectory;

    public static final String METADATA_FILE_NAME = "plugin-under-test-metadata.properties";
    private final ConfigurableFileCollection pluginClasspath = getProject().files();
    private final DirectoryProperty outputDirectory = getProject().getObjects().directoryProperty();

    /**
     * The code under test. Defaults to {@code sourceSets.main.runtimeClasspath}.
     */
    @Classpath
    public ConfigurableFileCollection getPluginClasspath() {

abstract class MyCopyTask : DefaultTask() {

    @get:InputDirectory abstract val source: DirectoryProperty

    @get:OutputDirectory abstract val destination: DirectoryProperty

    @get:Inject abstract val fs: FileSystemOperations

    @TaskAction
    fun action() {
        fs.copy {
            from(source)
            into(destination)
        }
    }
}

// tag::fixed-reuse[]
tasks.register<MyCopyTask>("someTask") {

abstract class MyCopyTask extends DefaultTask {

    @InputDirectory abstract DirectoryProperty getSource()

    @OutputDirectory abstract DirectoryProperty getDestination()

    @Inject abstract FileSystemOperations getFs()

    @TaskAction
    void action() {
        fs.copy {
            from source
            into destination
        }
    }
}

// tag::fixed-reuse[]
tasks.register('someTask', MyCopyTask) {

// tag::fixed[]
abstract class MyCopyTask : DefaultTask() { // <1>

    @get:InputDirectory abstract val source: DirectoryProperty // <2>

    @get:OutputDirectory abstract val destination: DirectoryProperty // <2>

    @get:Inject abstract val fs: FileSystemOperations // <3>

    @TaskAction
    fun action() {
        fs.copy { // <3>
            from(source)
            into(destination)
        }
    }
}

package org.example;

import java.util.HashMap;
import javax.inject.Inject;
import org.gradle.api.DefaultTask;
import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.FileCollection;
import org.gradle.api.file.FileSystemOperations;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.*;

// tag::custom-task-class[]

            task.setClasspath(extension.getClasspath());

            // TODO: This should be in Javadoc task
            DirectoryProperty generatedJavadocDirectory = objects.directoryProperty();
            generatedJavadocDirectory.set(layout.getBuildDirectory().dir("javadoc"));
            task.getOutputs().dir(generatedJavadocDirectory);

import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;

public abstract class DocsGenerate extends DefaultTask {

    @Input
    public abstract Property<String> getTitle();

    @OutputDirectory
    public abstract DirectoryProperty getOutputDir();

    @TaskAction

        this.delegate = delegate;
    }

    @Override
    public DirectoryProperty getDistsDirectory() {
        logDeprecation();
        return delegate.getDistsDirectory();
    }

    @Override
    public DirectoryProperty getLibsDirectory() {
        logDeprecation();
        return delegate.getLibsDirectory();
    }

    @Override