FileUtils.write(resultsJson, JsonOutput.toJson(resultData), Charset.defaultCharset())
    }

    static String collectFailures(JUnitTestCase testCase) {
        List<JUnitFailure> failures = testCase.failures ?: []
        return failures.collect { it.value }.join("\n")
    }

    private List<ScenarioBuildResultData> extractResultFromTestSuite(JUnitTestSuite testSuite, String testProject) {

        return buildList {
            fun visit(result: FailingResult) {
                when (result) {
                    is MultipleFailuresResult -> result.failures.forEach(::visit)
                    is ParsingError -> add(SyntaxError(result))
                    is UnsupportedConstruct -> add(UnsupportedKotlinFeature(result))
                }
            }

                    final String urlValue = Pattern.quote(u);
                    crawler.addExcludeFilter(urlValue);
                    if (logger.isInfoEnabled()) {
                        logger.info("Excluded URL from failures: {}", urlValue);
                    }
                });
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Crawling {}", urlsStr);
            }

  private void handleException(Throwable throwable) {
    checkNotNull(throwable);

    if (allMustSucceed) {
      // As soon as the first one fails, make that failure the result of the output future.
      // The results of all other inputs are then ignored (except for logging any failures).
      boolean completedWithFailure = setException(throwable);
      if (!completedWithFailure) {

        fun recurseDeeper(next: LanguageResult<*>) = recurse(next, depth + 1)
        when (current) {
            is MultipleFailuresResult -> {
                appendIndented("MultipleFailures(\n")
                current.failures.forEach {
                    recurseDeeper(it)
                    appendLine()
                }
                appendIndented(")")
            }
            is ParsingError -> {

  private void handleException(Throwable throwable) {
    checkNotNull(throwable);

    if (allMustSucceed) {
      // As soon as the first one fails, make that failure the result of the output future.
      // The results of all other inputs are then ignored (except for logging any failures).
      boolean completedWithFailure = setException(throwable);
      if (!completedWithFailure) {

  in which there is no network connection, and providing a robust m2 service
  offering in such circumstances. Introduction of offline mode allows m2 to
  anticipate the inevitable network failures that accompany being physically
  disconnected from the network, and adjust it's behavior accordingly.

  It is more than simply understanding that m2 cannot go and check for the

import org.gradle.internal.declarativedsl.language.LocalValue
import org.gradle.internal.declarativedsl.language.Null
import org.gradle.internal.declarativedsl.language.PropertyAccess


// TODO: report failures to resolve with potential candidates that could not work
data class PropertyReferenceResolution(
    val receiverObject: ObjectOrigin,
    val property: DataProperty
) {

        // notify listeners about "soft" project build failures only
        if (t instanceof Exception && !(t instanceof RuntimeException)) {
            eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, currentSession, null, (Exception) t);
        }

        // reactor failure modes
        if (t instanceof RuntimeException || !(t instanceof Exception)) {

It looks like the following:

```
Execution failed for task ':architecture-test:checkBinaryCompatibility'.
> A failure occurred while executing me.champeau.gradle.japicmp.JApiCmpWorkAction
   > Detected binary changes.
         - current: ...
         - baseline: ...
     
     See failure report at file:///<path to Gradle checkout>/subprojects/architecture-test/build/reports/binary-compatibility/report.html
```