List<TestFailure> failures = new ArrayList<TestFailure>();

        List<Throwable> innerExceptions = invokeMethod(throwable, "getFailures", List.class);
        for (Throwable innerException : innerExceptions) {
            failures.add(mapper.createFailure(innerException));
        }

        return failures;
    }

        }
        return toFailureContainer(((InternalBasicProblemDetailsVersion2) problemDetails).getFailure());
    }

    private static FailureContainer toFailureContainer(@Nullable InternalBasicProblemDetailsVersion3 problemDetails) {
        return toFailureContainer(problemDetails == null ? null : problemDetails.getFailure());
    }

    private static FailureContainer toFailureContainer(@Nullable InternalFailure failure) {

        return id;
    }

    public String getName() {
        return name;
    }

    public String getDisplayName() {
        return displayName;
    }

    public List<TestFailure> getFailures() {
        return failures;
    }

    public TestResult.ResultType getResultType() {
        return resultType;
    }

    public long getDuration() {
        return duration;
    }

        ParallelResolveArtifactSet.wrap(artifacts, buildOperationExecutor).visit(collectingVisitor);
        if (!lenient && !collectingVisitor.getFailures().isEmpty()) {
            throw UncheckedException.throwAsUncheckedException(collectingVisitor.getFailures().iterator().next());
        }
        return collectingVisitor.getArtifacts();
    }

            public Throwable transform(TestFailure testFailure) {
                return testFailure.getRawFailure();
            }
        });
    }

    @Override
    public List<TestFailure> getFailures() {
        return failures;
    }

    @Override
    public long getStartTime() {
        return startTime;
    }

    @Override
    public long getEndTime() {
        return endTime;
    }

        return duration;
    }

    @Override
    public String getFormattedDuration() {
        return getTestCount() == 0 ? "-" : super.getFormattedDuration();
    }

    public Set<TestResult> getFailures() {
        return failures;
    }

    public Set<TestResult> getIgnored() {
        return ignored;
    }

    @Override
    public ResultType getResultType() {

     *
     * @return The failures, if any, logged for this test. If none, an empty list is returned.
     * @see #getExceptions()
     * @since 7.6
     */
    @Incubating
    List<TestFailure> getFailures();

    /**
     * If the test failed with any exceptions, this will contain the exceptions.  Some test frameworks do not fail
     * without an exception (JUnit), so in those cases this method will never return an empty list.

                    resolvedArtifacts.put(resolvedArtifact.getId(), resolvedArtifact);
                    configurations.put(resolvedArtifact.getId(), configuration);
                }
                if (artifacts.getFailures().isEmpty()) {
                    continue;
                }
                for (UnresolvedDependencyResult unresolvedDependency : getUnresolvedDependencies(configuration, visitor)) {

            .assertTestFailed("allCausesShouldBeCaptured",
                containsString("Cause 2: java.lang.RuntimeException: error 2"))

        where:
        methodName << [
            'getFailures',
            'getCauses'
        ]
    }

    @Issue("https://github.com/gradle/gradle/issues/9487")
    def 'break cycles with suppressed and cause exceptions'() {
        given:

            Throwable reportableFailure = failure;
            if (reportableFailure == null && !stageFailures.getFailures().isEmpty()) {
                reportableFailure = exceptionAnalyser.transform(stageFailures.getFailures());
            }
            BuildResult buildResult = new BuildResult(hasTasks ? "Build" : "Configure", gradle, reportableFailure);