LOG.info("Generating HTML test report...");

        Timer clock = Time.startTimer();
        AllTestResults model = loadModelFromProvider(resultsProvider);
        generateFiles(model, resultsProvider, reportDir);
        LOG.info("Finished generating test html results ({}) into: {}", clock.getElapsed(), reportDir);
    }

    ) {
        fileOperations.delete {
           it.delete(reportDir)
        }
        ByteArrayOutputStream output = new ByteArrayOutputStream()

        ExecResult result = execOperations.javaexec(new Action<JavaExecSpec>() {
            void execute(JavaExecSpec spec) {
                spec.getMainClass().set(reportGeneratorClass)
                spec.args(reportDir.path, projectName)
                spec.args(resultJsons*.path)

        return spec
    }

    private static TestFile resolveSingleConfigurationCacheReportDir(TestFile rootDir) {
        TestFile reportsDir = rootDir.file("build/reports/configuration-cache")
        List<TestFile> reportDirs = []
        Files.walkFileTree(reportsDir.toPath(), new SimpleFileVisitor<Path>() {
            @Override
            FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {

import org.gradle.api.internal.tasks.testing.junit.result.TestResultsProvider;

import java.io.File;

public interface TestReporter {
    void generateReport(TestResultsProvider testResultsProvider, File reportDir);

     * or fail with one or more exceptions, or all of the above.
     *
     * @param reportDir The base directory that reports can be generated into.
     * @param validationFailures Collects any validation failures.
     */
    void report(File reportDir, ProblemConsumer validationFailures);

     *
     * @return the directory to store project reports
     * @since 7.1
     */
    @Internal
    public DirectoryProperty getProjectReportDirectory() {
        return reportDir;
    }

    protected ConventionReportTask() {
        reportDir = getProject().getObjects().directoryProperty();
        doNotTrackState("Uses the whole project state as an input");
    }

    @Internal

        outputs.doNotCacheIf("Debug enabled") { debugReportGeneration.get() }
    }

    @TaskAction
    fun generateReport() {
        val reporter = PerformanceReporter(execOperations, fileOperations)
        reporter.report(
            reportGeneratorClass.get(),
            reportDir.get().asFile,
            performanceResults,
            databaseParameters.get(),
            channel.get(),
            channelPatterns.get(),

import java.io.File;

public class DeprecationsReporter implements ProblemReporter {
    @Override
    public String getId() {
        return "deprecations";
    }

    @Override
    public void report(File reportDir, ProblemConsumer validationFailures) {
        Throwable failure = DeprecationLogger.getDeprecationFailure();
        if (failure != null) {
            validationFailures.accept(failure);
        }
    }

}

fun Task.attachedReportLocations() = when (this) {
    is JapicmpTask -> listOf(richReport.get().destinationDir.get().asFile.resolve(richReport.get().reportName.get()))
    is PerformanceTest -> listOf(reportDir.parentFile)
    else -> emptyList()

        }
    };

    @Override
    public String getId() {
        return "problems";
    }

    @Override
    public void report(File reportDir, ProblemConsumer validationFailures) {
        problemAggregator.ifPresent(AggregatingProblemConsumer::sendProblemSummaries);
    }