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;
    }

    @Override
    public boolean requireArtifactFiles() {
        return true;
    }

    public Set<ResolvedArtifactResult> getArtifacts() {
        return artifacts;
    }

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

    @Override
    public boolean requireArtifactFiles() {
        return false;
    }

    public Set<ResolvedArtifact> getArtifacts() {
        return artifacts;
    }

    public List<Throwable> getFailures() {
        return failures != null ? failures : Collections.emptyList();
    }

     * Returns any failures to resolve the artifacts for this collection.
     *
     * @since 4.0
     *
     * @return A collection of exceptions, one for each failure in resolution.
     */
    Collection<Throwable> getFailures();

            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 ignored ? "-" : super.getFormattedDuration();
    }

    public ClassTestResults getClassResults() {
        return classResults;
    }

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

    public boolean isIgnored() {
        return ignored;
    }

    public void addFailure(TestFailure failure) {
        classResults.failed(this);

        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();
    }

        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() {

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