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() {

 */
@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();
    }

    void copyTo(AbstractExternalModuleDependency target);

    ImmutableAttributesFactory getAttributesFactory();

    NotationParser<Object, Capability> getCapabilityNotationParser();

    ObjectFactory getObjectFactory();

    private List<String> loggingPhases;

    private ScalaForkOptions forkOptions = getObjectFactory().newInstance(ScalaForkOptions.class);

    private IncrementalCompileOptions incrementalOptions;

    private final Property<KeepAliveMode> keepAliveMode = getObjectFactory().property(KeepAliveMode.class);

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

    /**

    private EclipseWtpFacet facet;

    /**
     * Injects and returns an instance of {@link ObjectFactory}.
     *
     * @since 4.9
     */
    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();
    }

    /**
     * Configures wtp component.
     * <p>
     * For examples see docs for {@link EclipseWtpComponent}
     */