reader.writeAllOutput(classId, destination, writer);
            }
        });
    }

    @Override
    public boolean isHasResults() {
        return resultSerializer.isHasResults();
    }

    @Override
    public void writeNonTestOutput(final long classId, final TestOutputEvent.Destination destination, final Writer writer) {

        }
    }

    @Override
    public boolean isHasResults() {
        return any(providers, new Spec<TestResultsProvider>() {
            @Override
            public boolean isSatisfiedBy(TestResultsProvider element) {
                return element.isHasResults();
            }
        });
    }

    @Override

            encoder.writeString(testFailure.getMessage());
            encoder.writeString(testFailure.getStackTrace());
        }
    }

    public void read(Action<? super TestClassResult> visitor) {
        if (!isHasResults()) {
            return;
        }
        try {
            InputStream inputStream = new FileInputStream(resultsFile);
            try {
                Decoder decoder = new KryoBackedDecoder(inputStream);

    public void visitClasses(final Action<? super TestClassResult> visitor) {
        for (TestClassResult result : results) {
            visitor.execute(result);
        }
    }

    @Override
    public boolean isHasResults() {
        return results.iterator().hasNext();
    }

    boolean hasOutput(long classId, TestOutputEvent.Destination destination);

    boolean hasOutput(long classId, long testId, TestOutputEvent.Destination destination);

    boolean isHasResults();

            }
        }
    }

    void visitClasses(Action<? super TestClassResult> visitor) {
        testClasses.values().each {
            visitor.execute(it)
        }
    }

    boolean isHasResults() {
        !testClasses.isEmpty()
    }

    boolean hasOutput(long classId, TestOutputEvent.Destination destination) {
        testClasses[classId]?.outputEvents?.find { it.testOutputEvent.destination == destination }

        }
    }

    @TaskAction
    void generateReport() {
        TestResultsProvider resultsProvider = createAggregateProvider();
        try {
            if (resultsProvider.isHasResults()) {
                DefaultTestReport testReport = new DefaultTestReport(getBuildOperationRunner(), getBuildOperationExecutor());

    private
    fun containsFailedTest(testBinaryResultsDir: File): Boolean {
        var containingFailures = false

        val serializer = TestResultSerializer(testBinaryResultsDir)
        if (serializer.isHasResults) {
            serializer.read {
                if (failuresCount > 0) {
                    containingFailures = true
                }
            }
        }
        return containingFailures
    }

    }

    private Set<String> getPreviousFailedTestClasses() {
        TestResultSerializer serializer = new TestResultSerializer(getBinaryResultsDirectory().getAsFile().get());
        if (serializer.isHasResults()) {
            final Set<String> previousFailedTestClasses = new HashSet<String>();
            serializer.read(new Action<TestClassResult>() {
                @Override