Como parte disso, eu precisava investigar, testar e usar muitas alternativas.

A história do **FastAPI** é, em grande parte, a história de seus predecessores.

Como dito na seção [Alternativas](alternatives.md){.internal-link target=_blank}:

<blockquote markdown="1">

    TestFile testFile
    TestFile testFileLock
    TestFile testDir
    TestFile testDirLock

    List<Closeable> openedLocks = []

    def setup() {
        testFile = tmpDir.createFile("state.bin")
        testFileLock = tmpDir.file(testFile.name + ".lock")
        testDir = tmpDir.createDir("lockable-dir")
        testDirLock = tmpDir.file("${testDir.name}/${testDir.name}.lock")

        metaDataProvider.processIdentifier >> '123'

@UsesNativeServices
class AbstractGradleExecuterTest extends Specification {
    @Rule
    public final TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass());

    def gradleDistribution = Mock(GradleDistribution)

    AbstractGradleExecuter executer = new AbstractGradleExecuter(gradleDistribution, testDir) {
        @Override
        protected ExecutionResult doRun() {
            return null
        }

	// Add "." to PATH so that exec.LookPath looks in the current directory on all systems.
	// And try to trick it with "../testdir" too.
	for _, errdot := range []string{"1", "0"} {
		t.Run("GODEBUG=execerrdot="+errdot, func(t *testing.T) {
			t.Setenv("GODEBUG", "execerrdot="+errdot+",execwait=2")
			for _, dir := range []string{".", "../testdir"} {
				t.Run(pathVar+"="+dir, func(t *testing.T) {
					t.Setenv(pathVar, dir+string(filepath.ListSeparator)+origPath)

        assertThat(foo.isStatic(), is(not(true)));
        foo.invokeStatic();
    }

    /**
     * @throws Exception
     */
    @Test
    public void testBar() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc bar = beanDesc.getMethodDesc("bar", String.class);
        assertThat(bar, is(notNullValue()));

import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

class DefaultNativeToolChainRegistryTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())

    def project = TestUtil.create(testDir).rootProject()

    def instantiator = project.services.get(Instantiator)

			}
			stateErr = tt.testErr

			_, stale, err := transformer.TransformFromStorage(ctx, transformedData, dataCtx)
			if tt.testErr != nil {
				if err == nil {
					t.Fatalf("envelopeTransformer: expected error: %v, got nil", tt.testErr)
				}
				if err.Error() != tt.testErr.Error() {
					t.Fatalf("envelopeTransformer: expected error: %v, got: %v", tt.testErr, err)
				}
			} else {

class DefaultCopySpecResolutionTest extends Specification {

    @Rule
    public TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())
    def fileResolver = TestFiles.resolver(testDir.testDirectory)
    def fileCollectionFactory = TestFiles.fileCollectionFactory(testDir.testDirectory)
    def objectFactory = TestUtil.objectFactory()
    def instantiator = TestUtil.instantiatorFactory().decorateLenient()

)

func TestSecretboxKeyRotation(t *testing.T) {
	testErr := fmt.Errorf("test error")
	ctx := context.Background()
	dataCtx := value.DefaultContext([]byte("authenticated_data"))

	p := value.NewPrefixTransformers(testErr,
		value.PrefixTransformer{Prefix: []byte("first:"), Transformer: NewSecretboxTransformer(key1)},

    private TestFile testDir
    private File downloadedFile
    private URI sourceUri
    private RelativeFilePathResolver resolver = Mock()

    private TextResource underTest

    @Rule
    public TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass());

    def setup() {
        testDir = tmpDir.createDir('dir')