return attachOwner(getObjectFactory().fileCollection(), owner, propertyName);
        }
        if (type.isAssignableFrom(ConfigurableFileTree.class)) {
            return attachOwner(getObjectFactory().fileTree(), owner, propertyName);
        }
        if (type.isAssignableFrom(DirectoryProperty.class)) {
            return attachOwner(getObjectFactory().directoryProperty(), owner, propertyName);
        }

import org.gradle.workers.WorkerExecutor;

// tag::download[]
public abstract class Download extends DefaultTask {
    // Use an abstract getter method
    @Inject
    protected abstract ObjectFactory getObjectFactory();

    // Alternatively, use a getter method with a dummy implementation
    @Inject
    protected WorkerExecutor getWorkerExecutor() {
        // Method body is ignored

    private final ExtensiblePolymorphicDomainObjectContainer<TestSuite> suites;

    @Inject
    public DefaultTestingExtension() {
        this.suites = getObjectFactory().polymorphicDomainObjectContainer(TestSuite.class);
    }

    @Inject
    public abstract ObjectFactory getObjectFactory();

    @Override
    public ExtensiblePolymorphicDomainObjectContainer<TestSuite> getSuites() {
        return suites;
    }

        this.capabilityNotationParser = capabilityNotationParser;
    }

    @Inject
    protected abstract ObjectFactory getObjectFactory();

    @Override
    public abstract SetProperty<Capability> getRequestedCapabilities();

    @Override
    public void requireCapability(Object capabilityNotation) {

         *
         * @return injected service
         * @implSpec Do not implement this method. Gradle generates the implementation automatically.
         */
        @Inject
        protected abstract ObjectFactory getObjectFactory();

        /**
         * {@inheritDoc}
         *
         * Selects the platform variant of the given dependency.
         */
        @Override

    @Inject
    abstract protected DependencyFactory getDependencyFactory();

    @Inject
    abstract protected ObjectFactory getObjectFactory();

    @Override
    public TestFramework createTestFramework(Test task) {
        return new TestNGTestFramework(task, (DefaultTestFilter) task.getFilter(), getObjectFactory());
    }

    @Override
    public Iterable<Dependency> getImplementationDependencies() {

    private final DefaultExecSpec execSpec;

    public AbstractExecTask(Class<T> taskType) {
        execSpec = getObjectFactory().newInstance(DefaultExecSpec.class);
        execResult = getObjectFactory().property(ExecResult.class);
        this.taskType = taskType;
    }

    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();
    }

    @Inject

 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class TestReport extends DefaultTask {
    private final DirectoryProperty destinationDir = getObjectFactory().directoryProperty();
    private final ConfigurableFileCollection resultDirs = getObjectFactory().fileCollection();

    @Inject
    protected BuildOperationRunner getBuildOperationRunner() {
        throw new UnsupportedOperationException();
    }

    private final Map<Long, ResolutionData> resolutionData = new ConcurrentHashMap<>();
    private final Lazy<InjectedInstrumentationServices> internalServices = Lazy.locking().of(() -> getObjectFactory().newInstance(InjectedInstrumentationServices.class));

    @Inject protected abstract ObjectFactory getObjectFactory();
    @Inject protected abstract StyledTextOutputFactory getTextOutputFactory();
    @Inject protected abstract FileResolver getFileResolver();

    protected abstract AbstractConfigurationReportSpec buildReportSpec();

    public AbstractConfigurationReportTask() {
        reports = getObjectFactory().newInstance(ConfigurationReportsImpl.class, this);
    }