then:
        def e = thrown(GradleConnectionException)
        def exceptionString = getStackTraceAsString(e)
        !exceptionString.contains(NotSerializableException.getName())
        exceptionString.contains('Caused by: CustomException: Something went wrong in building the model')

        where:
        exceptionNestingLevel << (0..2).toList()
    }

    @Issue("GRADLE-3307")
    @TargetGradleVersion(">=3.2")

     *
     * @param problems The problems that cause this exception, must not be {@code null}.
     */
    public ToolchainsBuildingException(List<Problem> problems) {
        super(toMessage(problems));

        this.problems = new ArrayList<>();
        if (problems != null) {
            this.problems.addAll(problems);
        }
    }

    /**
     * Gets the problems that caused this exception.
     *

   *     a new event based on the error.
   */
  public EventBus getEventBus() {
    return eventBus;
  }

  /** @return The event object that caused the subscriber to throw. */
  public Object getEvent() {
    return event;
  }

  /** @return The object context that the subscriber was called on. */
  public Object getSubscriber() {
    return subscriber;
  }

        for (final Throwable t : throwables) {
            s.println("Caused " + count + ":");
            t.printStackTrace(s);
            count++;
        }
    }

    @Override
    public void printStackTrace(final PrintWriter s) {
        super.printStackTrace(s);

        int count = 1;
        for (final Throwable t : throwables) {
            s.println("Caused " + count + ":");
            t.printStackTrace(s);

# A missing $CC caused the C dependencies of the net
# package to appear stale, and it could not be rebuilt due to a missing $CC.

[!cgo] skip

# This test may start with the runtime/cgo package already stale.
# Explicitly rebuild it to ensure that it is cached.
# (See https://go.dev/issue/50892.)
#
# If running in non-short mode, explicitly vary CGO_CFLAGS
# as a control case (to ensure that our regexps do catch rebuilds).

"""
    }

    def "optionally shows causes"() {
        def causeCause = new RuntimeException("oops").tap { stackTrace = createCauseCauseTrace() }
        def cause = new IllegalArgumentException("ouch", causeCause).tap { stackTrace = createCauseTrace() }
        def exception = new Exception("argh", cause).tap { stackTrace = createStackTrace() }

        testLogging.showCauses >> true

// Panics caused by user error (that is, everything except run-time panics
// such as "index out of bounds" errors) do not leave the file that caused
// them, but are instead turned into plain error returns. Encoding and
// decoding functions and methods that do not return an error either use
// panic to report an error or are guaranteed error-free.

	for i := 0; i < 10; i++ {
		// 6g had a bug that caused select to pass &t to
		// selectrecv before allocating the memory for t,
		// which caused non-deterministic crashes.
		// This test looks for the bug by checking that the
		// value received actually ends up in t.
		// If the allocation happens after storing through
		// whatever garbage &t holds, the later reference
		// to t in the case body will use the new pointer and

     *
     * @param problems The problems that cause this exception, may be {@code null}.
     */
    public SettingsBuildingException(List<SettingsProblem> problems) {
        super(toMessage(problems));

        this.problems = new ArrayList<>();
        if (problems != null) {
            this.problems.addAll(problems);
        }
    }

    /**
     * Gets the problems that caused this exception.
     *

 */

// We want to double check that a build failure is
// only caused by failing test executions
gradle.buildFinished { result ->
    buildDir.mkdirs()
    if(result.failure) {
        def unexpectedFailure = (result.failure instanceof org.gradle.execution.MultipleBuildFailures && result.failure.causes.every { cause ->
            def failureMessage = cause?.cause?.cause?.message
            !failureMessage?.contains("There were failing tests")