configurationCache.assertStateLoaded()
        findReport()
    }

    private TestFile findReport() {
        def reportFile = file('build/reports/profile').listFiles().find { it.name ==~ /profile-.+.html/ }
        assert reportFile && reportFile.exists()
        reportFile
    }

        def snapshot = reportFile.snapshot()
        then:
        executedAndNotSkipped ":test", ":jacocoTestReport", ":jacocoTestCoverageVerification"
        reportFile.assertIsFile()

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:

                val reportFile = reportDir.resolve(HtmlReportTemplate.reportHtmlFileName)
                if (!reportFile.exists()) {
                    require(reportDir.mkdirs()) {
                        "Could not create configuration cache report directory '$reportDir'"
                    }
                    Files.move(spoolFile.toPath(), reportFile.toPath())
                }

@CompileStatic
class TaskValidationReportFixture {
    public static final String PROBLEM_SEPARATOR = "\n--------\n"
    private final File reportFile

    TaskValidationReportFixture(File reportFile) {
        this.reportFile = reportFile
    }

    void verify(Map<String, Severity> messages) {
        def expectedReportContents = messages
            .collect { message, severity ->

        private final TestClassResult result;
        private final File reportFile;
        private final JUnitXmlResultWriter xmlWriter;

        public JUnitXmlReportFileGenerator(TestClassResult result, File reportFile, JUnitXmlResultWriter xmlWriter) {
            this.result = result;
            this.reportFile = reportFile;
            this.xmlWriter = xmlWriter;
        }

        @Override

        output.contains("Hello from settings plugin")
        findReport()
    }


    private TestFile findReport() {
        def reportFile = file('build/reports/profile').listFiles().find { it.name ==~ /profile-.+.html/ }
        assert reportFile && reportFile.exists()
        reportFile
    }

            .getAsFile()
            .get();
    }

    private void renderReportUrl(File reportFile) {
        StyledTextOutput textOutput = textOutputFactory.create(ReportGeneratingProfileListener.class, LogLevel.LIFECYCLE);
        textOutput.println();
        String reportUrl = new ConsoleRenderer().asClickableFileUrl(reportFile);
        textOutput.formatln("See the profiling report at: %s", reportUrl);

        private final String pluginId
        private final File reportFile

        private Map<String, Severity> messages = [:]

        boolean skipped
        boolean tested

        PluginValidation(String id, TestFile buildDir, AbstractSmokeTest owner) {
            this.pluginId = id
            this.owner = owner
            this.reportFile = buildDir.file("reports/plugins/validation-report-for-${reportId}.txt")

            append(if (uniqueProblemCount == 1) "seems unique" else "seem unique")
        }
        append(".")
    }

    private
    fun buildSummaryReportLink(reportFile: File) =
        "See the complete report at ${clickableUrlFor(reportFile)}"

    private
    fun clickableUrlFor(file: File) =
        ConsoleRenderer().asClickableFileUrl(file)
}


private
fun consoleComparator() =

        File reportFile = testDirectory.parentFile.parentFile.parentFile.parentFile.file("reports/tests/resolution-failure-showcase.txt")

        when:
        generateFailureShowcase(reportFile)

        then:
        assertAllExceptionsInShowcase(reportFile)

        println("Resolution error showcase report available at: ${reportFile.toURI()}")
    }