this.providerFactory = providerFactory;
    }

    @Override
    public TaskProvider<? extends Task> createTask(Project project) {
        return project.getTasks().register("licenseHeaders", LicenseHeadersTask.class, licenseHeadersTask -> {
            project.getPlugins().withType(JavaBasePlugin.class, javaBasePlugin -> {

        project.getPlugins().apply(DokkaPlugin.class);
    }

    private static void updateDocumentationExtension(Project project, GradleDocumentationExtension extension) {
        TaskProvider<Task> generateTask = project.getTasks().named(TASK_NAME);
        Provider<? extends Directory> outputDirectory = generateTask.flatMap(t -> ((DokkaGeneratePublicationTask) t).getOutputDirectory());

        GradleUtils.extendSourceSet(project, SourceSet.TEST_SOURCE_SET_NAME, SOURCE_SET_NAME);

        // add alias task that is easier to type
        project.getTasks().register("icTest").configure(alias -> alias.dependsOn(SOURCE_SET_NAME));
    }

    public static final String TASK_NAME = "splitPackagesAudit";

    @Override
    public TaskProvider<? extends Task> createTask(Project project) {
        TaskProvider<SplitPackagesAuditTask> task = project.getTasks().register(TASK_NAME, SplitPackagesAuditTask.class);
        task.configure(t -> {
            t.setClasspath(project.getConfigurations().getByName(JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME));

    @Override
    public TaskProvider<? extends Task> createTask(Project project) {
        TaskProvider<TestingConventionsTasks> testingConventions = project.getTasks()
            .register("testingConventions", TestingConventionsTasks.class);
        testingConventions.configure(t -> {
            TestingConventionRule testsRule = t.getNaming().maybeCreate("Tests");

            project.getDependencies().add("loggerUsagePlugin", project.project(":test:logger-usage"));
        }
        TaskProvider<LoggerUsageTask> loggerUsage = project.getTasks().register("loggerUsageCheck", LoggerUsageTask.class);
        loggerUsage.configure(t -> t.setClasspath(loggerUsageConfig));
        return loggerUsage;
    }

    public final void apply(Project project) {
        project.getPluginManager().apply(PrecommitTaskPlugin.class);
        TaskProvider<? extends Task> task = createTask(project);
        TaskProvider<Task> precommit = project.getTasks().named(PRECOMMIT_TASK_NAME);
        precommit.configure(t -> t.dependsOn(task));
        project.getPluginManager().withPlugin("java", p -> {

        // the basename here to indicate its a test artifacts jar.
        BasePluginExtension pluginExtension = project.getExtensions().getByType(BasePluginExtension.class);
        project.getTasks().named(name + "Jar", Jar.class).configure(jar -> {
            jar.getArchiveBaseName()
                .convention(providerFactory.provider(() -> pluginExtension.getArchivesName().get() + "-" + name + "-artifacts"));

        final String url = System.getenv("SCA_URL");
        final String token = System.getenv("SCA_TOKEN");
        TaskProvider<DependenciesGraphTask> depsGraph = project.getTasks().register("dependenciesGraph", DependenciesGraphTask.class);
        depsGraph.configure(t -> {
            project.getPlugins().withType(JavaPlugin.class, p -> {

        ext.set("licenseFile", null);
        ext.set("noticeFile", null);
        // add license/notice files
        project.afterEvaluate(p -> p.getTasks().withType(Jar.class).configureEach(jar -> {
            if (ext.has("licenseFile") == false
                || ext.get("licenseFile") == null
                || ext.has("noticeFile") == false