cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		err := cmd.Run()
		if err != nil {
			if e, ok := err.(*exec.ExitError); ok && e.ProcessState != nil {
				if e.ProcessState.Exited() {
					os.Exit(e.ProcessState.ExitCode())
				}
				base.Fatalf("exec %s: %s", gotoolchain, e.ProcessState)
			}
			base.Fatalf("exec %s: %s", exe, err)
		}
		os.Exit(0)
	}

     *
     * @return this
     */
    ExecHandle start();

    void removeStartupContext();

    ExecHandleState getState();

    /**
     * Aborts the process, blocking until the process has exited. Does nothing if the process has already completed.
     */
    void abort();

    /**
     * Waits for the process to finish. Returns immediately if the process has already completed.
     *
     * @return result

// example, if the currently running program was not built with
// "-cover", or if the directory does not exist).
func WriteMetaDir(dir string) error {
	return cfile.WriteMetaDir(dir)
}

// WriteMeta writes the meta-data content (the payload that would
// normally be emitted to a meta-data file) for the currently running
// program to the writer 'w'. An error will be returned if the

kind: VirtualService
metadata:
  name: validation-readiness-dummy-virtual-service
  namespace: %s
spec:
  hosts:
    - non-existent-host
  http:
    - route:
      - destination:
          host: non-existent-host
          subset: v1
        weight: 75
      - destination:
          host: non-existent-host
          subset: v2
        weight: 25
`

        this.args.addAll(args as List)
        return this
    }

    ExecOutput build() {
        def result = run()
        if (result.exitCode != 0) {
            throw new AssertionError("Swift PM exited with non-zero exit code. Output:\n${result.out}")
        }
        return result
    }

    ExecOutput buildAndFails() {
        def result = run()
        if (result.exitCode == 0) {

        proc.waitForFinish()
    }

    void outputContainsKilledWorkerWarning() {
        if (OperatingSystem.current().windows) {
            outputContains(" exited unexpectedly with exit code 1.")
        } else {
            outputContains(" exited unexpectedly after being killed with signal 9.  This is likely because an external process has killed the worker.")
        }
    }

			outb, err := cmd.CombinedOutput()
			out := string(outb)
			if err == nil {
				t.Fatalf("fuzzing succeeded unexpectedly; output:\n%s", out)
			}
			if !strings.Contains(out, tc.expectedError) {
				t.Errorf("exited without expected error %q; got\n%s", tc.expectedError, out)
			}
		})
	}
}

// libFuzzerSupported is a copy of the function internal/platform.FuzzInstrumented,
// because the internal package can't be used here.

# Codificador Compatível com JSON

Existem alguns casos em que você pode precisar converter um tipo de dados (como um modelo Pydantic) para algo compatível com JSON (como um `dict`, `list`, etc).

Por exemplo, se você precisar armazená-lo em um banco de dados.

Para isso, **FastAPI** fornece uma função `jsonable_encoder()`.

## Usando a função `jsonable_encoder`

 * limitations under the License.
 */

package org.gradle.api.problems.internal;

/**
 * A problem location that stores a task path if the problem was emitted meanwhile executing a task.
 */
public class DefaultTaskPathLocation implements TaskPathLocation {

    private final String buildTreePath;

    public DefaultTaskPathLocation(String buildTreePath) {

import groovy.transform.SelfType
import org.gradle.util.GradleVersion

@SelfType(BaseDeprecations)
trait WithAndroidDeprecations {

    void expectFilteredFileCollectionDeprecationWarning() {
        // This warning is emitted by the Kotlin Kapt plugin
        runner.expectLegacyDeprecationWarning(
            "The Configuration.fileCollection(Spec) method has been deprecated. " +
                "This is scheduled to be removed in Gradle 9.0. " +