}

if ("CI" in System.getenv() && project.name != "gradle-kotlin-dsl-accessors") {
    rootProject.plugins.apply(TestFilesCleanupRootPlugin::class.java)
    val globalExtension = rootProject.extensions.getByType<TestFilesCleanupBuildServiceRootExtension>()

    val projectState = objects.newInstance(TestFilesCleanupProjectState::class.java)

    globalExtension.projectStates.put(path, projectState)

            });
        });

        ReportingExtension reporting = project.getExtensions().getByType(ReportingExtension.class);
        reporting.getReports().registerBinding(JacocoCoverageReport.class, DefaultJacocoCoverageReport.class);

        // Iterate and configure each user-specified report.

        when:
        project.pluginManager.apply(JavaLibraryDistributionPlugin)

        then:
        project.plugins.hasPlugin(JavaLibraryPlugin.class)
        project.extensions.getByType(DistributionContainer.class) != null
        project.plugins.hasPlugin(DistributionPlugin.class)
        project.distributions.main.distributionBaseName.get() == project.name
    }

    def "adds distZip task to project"() {

        logDeprecation();
        this.projectReportDirName = projectReportDirName;
    }

    @Override
    public File getProjectReportDir() {
        logDeprecation();
        return project.getExtensions().getByType(ReportingExtension.class).file(projectReportDirName);
    }

    @Override
    public Set<Project> getProjects() {
        logDeprecation();
        return WrapUtil.toSet(project);
    }

            groovyDoc.setClasspath(mainFeature.getSourceSet().getOutput().plus(mainFeature.getSourceSet().getCompileClasspath()));

            SourceDirectorySet groovySourceSet = mainFeature.getSourceSet().getExtensions().getByType(GroovySourceDirectorySet.class);
            groovyDoc.setSource(groovySourceSet);
        });
    }

    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();
        TaskContainer tasks = project.getTasks();

        GradleDocumentationExtension extension = project.getExtensions().getByType(GradleDocumentationExtension.class);
        generateJavadocs(project, layout, tasks, extension);
    }

    private static final String TASK_NAME = "dokkatooGeneratePublicationHtml";

    @Override
    public void apply(Project project) {
        GradleDocumentationExtension documentationExtension = project.getExtensions().getByType(GradleDocumentationExtension.class);
        applyPlugin(project);
        updateDocumentationExtension(project, documentationExtension);
        configurePlugin(project, documentationExtension);
    }

        Provider<JavaToolchainSpec> toolchainOverride
    ) {
        JavaToolchainService service = project.getExtensions().getByType(JavaToolchainService.class);
        JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
        return toolchainOverride.orElse(extension.getToolchain())
            .flatMap(spec -> toolMapper.apply(service, spec));
    }

                }
            }

            test {
                test.extensions.getByType(JacocoTaskExtension).destinationFile = new File("$jacocoDestinationFile")
                systemProperty "jacocoAgentJar", configurations.jacocoRuntime.singleFile.absolutePath
                systemProperty "jacocoDestFile", test.extensions.getByType(JacocoTaskExtension).destinationFile.absolutePath
            }

            gradlePlugin {

 */
class PublishingPluginRules extends RuleSource {
    @Model
    PublishingExtension publishing(ExtensionContainer extensions) {
        return extensions.getByType(PublishingExtension.class);
    }

    @Model
    ProjectPublicationRegistry projectPublicationRegistry(ServiceRegistry serviceRegistry) {
        return serviceRegistry.get(ProjectPublicationRegistry.class);
    }