@Inject
    protected abstract DependencyFactory getDependencyFactory();

    @Override
    public TestFramework createTestFramework(Test task) {
        return new JUnitPlatformTestFramework((DefaultTestFilter) task.getFilter(), false, task.getDryRun());
    }

    @Override
    public Iterable<Dependency> getRuntimeOnlyDependencies() {

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

    ) {
        this.filter = filter;
        this.includeCategories = includeCategories;
        this.excludeCategories = excludeCategories;
        this.isDryRun = isDryRun;
    }

    public TestFilterSpec getFilter() {
        return filter;
    }

    public Set<String> getIncludeCategories() {
        return includeCategories;
    }

    public Set<String> getExcludeCategories() {
        return excludeCategories;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.util.Path;

@ServiceScope(Scope.BuildTree.class)
public interface TaskSelector {
    Spec<Task> getFilter(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

    TaskSelection getSelection(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

            public InstrumentationTypeRegistry getRegistry() {
                return InstrumentationTypeRegistry.EMPTY;
            }

            @Override
            public BytecodeInterceptorFilter getFilter() {
                return BytecodeInterceptorFilter.INSTRUMENTATION_ONLY;
            }
        };
    }

    @Inject
    protected abstract DependencyFactory getDependencyFactory();

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

    @Override
    public Iterable<Dependency> getImplementationDependencies() {
        return ImmutableSet.of(getDependencyFactory().create(GROUP_NAME + ":" + getParameters().getVersion().get()));

        InstrumentationTypeRegistry typeRegistry = typeRegistryAndFilter.getRegistry();
        BytecodeInterceptorFilter interceptorFilter = typeRegistryAndFilter.getFilter();
        ClasspathElementTransformFactory transformFactory = internalServices.get().getTransformFactory(isAgentSupported());

            this.build = build;
            this.filter = filter;
        }

        public BuildState getBuild() {
            return build;
        }

        public Spec<Task> getFilter() {
            return filter;
        }
    }

  EXPECT_THAT(depthwise_conv_op, NotNull());
  // The filter of the DepthwiseConv2dNativeOp is expected to be a constant.
  EXPECT_TRUE(isa<TF::ConstOp>(depthwise_conv_op.getFilter().getDefiningOp()));
}

TEST_F(ConstantFoldingTest, DepthwiseConvWeightNotFoldable) {
  constexpr absl::string_view kModuleCode = R"mlir(
    module {

            }
            Set<String> excludes = source.getExcludes();
            if (!excludes.isEmpty()) {
                builder.item("excludes", excludes);
            }
            Set<String> filterIncludes = source.getFilter().getIncludes();
            if (!filterIncludes.isEmpty()) {
                builder.item("limit to", filterIncludes);
            }
        }
    }