this.deleter = deleter;

        ObjectFactory objectFactory = getProject().getObjects();
        this.moduleName = objectFactory.property(String.class);
        this.moduleFile = objectFactory.fileProperty();
        this.modules = getProject().files();
        this.compilerArgs = objectFactory.listProperty(String.class);
        this.objectFileDir = objectFactory.directoryProperty();
        this.source = getProject().files();

// end::ad-hoc-task[]
    val buildDirectory = layout.buildDirectory
    val objectFactory = project.objects
    val injected = objectFactory.newInstance<Injected>()

// tag::ad-hoc-task[]
    doLast {
        // Process the templates here
// end::ad-hoc-task[]
        injected.fs.copy {
            into(buildDirectory.dir("genOutput2"))
            from(objectFactory.fileTree().from("src/templates"))
            expand("year" to "2012")

    private final ObjectFactory objectFactory;
    private final Property<SwiftXCTestBinary> testBinary;
    private final Property<SwiftComponent> testedComponent;
    private final DefaultComponentDependencies dependencies;

    @Inject
    public DefaultSwiftXCTestSuite(String name, ObjectFactory objectFactory) {
        super(name, SwiftXCTestBinary.class, objectFactory);

    private final DocumentationRegistry documentationRegistry;

    public CopyActionExecuter(Instantiator instantiator, ObjectFactory objectFactory, FileSystem fileSystem, boolean reproducibleFileOrder, DocumentationRegistry documentationRegistry) {
        this.instantiator = instantiator;
        this.objectFactory = objectFactory;
        this.fileSystem = fileSystem;
        this.reproducibleFileOrder = reproducibleFileOrder;

        super(type, instantiator, callbackDecorator);
        this.objectFactory = objectFactory;
        this.fileOperations = fileOperations;
    }

    @Override
    protected Distribution doCreate(String name) {

        this.name = name;
        this.componentName = componentName;
        this.visualStudioVersion = objectFactory.property(VersionNumber.class).convention(AbstractCppBinaryVisualStudioTargetBinary.DEFAULT_VISUAL_STUDIO_VERSION);

    private Action<? super ActionConfiguration> componentMetadataListerRuleConfiguration;
    private final ObjectFactory objectFactory;
    private final RepositoryContentDescriptorInternal repositoryContentDescriptor;

    protected AbstractArtifactRepository(ObjectFactory objectFactory, VersionParser versionParser) {
        this.objectFactory = objectFactory;
        this.repositoryContentDescriptor = createRepositoryDescriptor(versionParser);
    }

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.tasks.testing.Test;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.gradle.jvm.toolchain.internal.SpecificInstallationToolchainSpec;

import javax.annotation.Nullable;

public class TestExecutableUtils {

    @Nullable
    public static JavaToolchainSpec getExecutableToolchainSpec(Test task, ObjectFactory objectFactory) {

        super(fileCollectionFactory, objectFactory, instantiator, patternSetFactory);
        this.parentResolver = parentResolver;
        this.objectFactory = objectFactory;
        getFilePermissions().convention(parentResolver.getFilePermissions());
        getDirPermissions().convention(parentResolver.getDirPermissions());
    }

            return objectFactory.newInstance(DefaultJvmToolchainManagement.class, registry);
        }

        @Provides
        protected JdkCacheDirectory createJdkCacheDirectory(ObjectFactory objectFactory, GradleUserHomeDirProvider homeDirProvider, FileOperations operations, FileLockManager lockManager, JvmMetadataDetector detector) {