private final TestFailureDetails details;

    private final List<TestFailure> causes;

    public DefaultTestFailure(Throwable rawFailure, TestFailureDetails details, List<TestFailure> causes) {
        this.rawFailure = rawFailure;
        this.details = details;
        this.causes = causes;
    }

    @Override
    public Throwable getRawFailure() {
        return rawFailure;
    }

     * @param causes the list of cause failures; can be {@code null}
     * @return the new instance
     */
    public static TestFailure fromTestAssertionFailure(Throwable failure, String expected, String actual, List<TestFailure> causes) {
        return DefaultTestFailure.fromTestAssertionFailure(failure, expected, actual, causes);
    }

    /**
     * Todo
     * @since 8.3
     */

     * Do not call this constructor.
     *
     * @deprecated This constructor will be made protected in 9.0
     */
    @Deprecated
    public ResolveException(String message, Iterable<? extends Throwable> causes) {
        super(message, causes);

        DeprecationLogger.deprecateAction("Directly instantiating a ResolveException")
            .withContext("Instantiating this exception is reserved for Gradle internal use only.")

    }

    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory, Throwable... causes) {
        super(messageFactory, causes);
    }

    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory, Iterable<? extends Throwable> causes) {
        super(messageFactory, causes);
    }

    @Override
    public synchronized Throwable fillInStackTrace() {
        return this;
    }

        File propertiesFile = wrapperProperties(wrapperJar);
        File rootDir = rootDir(wrapperJar);

        CommandLineParser parser = new CommandLineParser();
        parser.allowUnknownOptions();
        parser.option(GRADLE_USER_HOME_OPTION, GRADLE_USER_HOME_DETAILED_OPTION).hasArgument();
        parser.option(GRADLE_QUIET_OPTION, GRADLE_QUIET_DETAILED_OPTION);

Then we use the request directly, and extract the body as `bytes`. This means that FastAPI won't even try to parse the request payload as JSON.

And then in our code, we parse that YAML content directly, and then we are again using the same Pydantic model to validate the YAML content:

=== "Pydantic v2"

    ```Python hl_lines="26-33"

don't provide any relevant packages. It also adds any missing entries
to go.sum and removes any unnecessary ones.

The -v flag causes tidy to print information about removed modules
to standard error.

The -e flag causes tidy to attempt to proceed despite errors
encountered while loading packages.

The -diff flag causes tidy not to modify go.mod or go.sum but
instead print the necessary changes as a unified diff. It exits

    private
    var causes = ArrayList<Throwable>(maxCauses)

    private
    val lock = ReentrantLock()

    fun get(): Summary = lock.withLock {
        Summary(
            problemCount,
            failureCount,
            suppressedCount,
            ImmutableSet.copyOf(uniqueProblems),
            ImmutableList.copyOf(causes),
            overflowed,
            maxCollectedProblems

        normaliseLineSeparators(e.cause.causes[0].cause.message) == "Execution failed for task ':secondTest'."
        normaliseLineSeparators(e.cause.causes[0].cause.cause.message).startsWith "There were failing tests. See the report at:"
        normaliseLineSeparators(e.cause.causes[1].cause.message) == "Execution failed for task ':test'."

	if err != nil {
		return err
	}

	file, err := parser.ParseFile(fset, filename, src, parserMode)
	if err != nil {
		return err
	}

	// Make sure file is in canonical format.
	// This "fmt" pseudo-fix cannot be disabled.
	newSrc, err := gofmtFile(file)
	if err != nil {
		return err
	}
	if !bytes.Equal(newSrc, src) {
		newFile, err := parser.ParseFile(fset, filename, newSrc, parserMode)
		if err != nil {