ver := normalizedBuildVersion(version)
	if len(ver) != 0 {
		return ver, nil
	}

	bucketURL, versionLabel, err := splitVersion(version)
	if err != nil {
		return "", err
	}

	// revalidate, if exact build from e.g. CI bucket requested.
	ver = normalizedBuildVersion(versionLabel)
	if len(ver) != 0 {
		return ver, nil
	}

// a cached environment is loaded for each MustBaseEnvSet call.
func BenchmarkLoadBaseEnv(b *testing.B) {
	ver := DefaultCompatibilityVersion()
	MustBaseEnvSet(ver, true)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		MustBaseEnvSet(ver, true)
	}
}

// BenchmarkLoadBaseEnvDifferentVersions is expected to be relatively slow, because a

Ele também foi feito como referência futura.

Então você poderá voltar e ver exatamente o que precisar.

## Rode o código

Todos os blocos de código podem ser copiados e utilizados diretamente (eles são, na verdade, arquivos Python testados).

                    try {
                        Version ver = versionScheme.parseVersion(v.getKey());
                        if (versionConstraint.containsVersion(ver)) {
                            versions.add(ver);
                            result.setRepository(ver, v.getValue());
                        }
                    } catch (InvalidVersionSpecificationException e) {

	const gitVersion = "foo"
	fakeclientDiscovery.FakedServerVersion = &pkgversion.Info{GitVersion: gitVersion}
	ver, err := c.Discovery().ServerVersion()
	if err != nil {
		t.Fatalf("Get ServerVersion failed.: %v", err)
	}
	if ver.GitVersion != gitVersion {
		t.Fatalf("GitVersion did not match, expected %s, got %s", gitVersion, ver.GitVersion)
	}

			continue
		}
		// if uv has tiered content we add a
		// free-version to track it for asynchronous
		// deletion via scanner.
		ver, err := x.getIdx(i)
		if err != nil {
			return err
		}

		if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
			return x.addVersion(freeVersion)
		}
		return nil
	}
	return nil

func extractKubernetesVersion(versionInfo *version.Info) (int, error) {
	ver, err := goversion.NewVersion(versionInfo.String())
	if err != nil {
		return 0, fmt.Errorf("could not parse %v", err)
	}
	// Segments provide slice of int eg: v1.19.1 => [1, 19, 1]
	num := ver.Segments()[1]
	return num, nil
}

// IsK8VersionSupported checks minimum supported Kubernetes version for Istio.

				t.Errorf("unexpected prefix: got %v wanted %v", filter.ProxyPrefixMatch, tt.expectedVersionPrefix)
			}
			for ver, match := range tt.matches {
				got := proxyMatch(&Proxy{Metadata: &NodeMetadata{IstioVersion: ver}}, filter)
				if got != match {
					t.Errorf("expected %v to match %v, got %v", ver, match, got)
				}
			}
		})
	}
}

func TestConvertEnvoyFilter(t *testing.T) {

	for v := range versions {
		sortedVersions = append(sortedVersions, v)
	}
	sort.Strings(sortedVersions)
	counts := []string{}
	for _, ver := range sortedVersions {
		counts = append(counts, fmt.Sprintf("%s (%d proxies)", ver, len(versions[ver])))
	}
	return strings.Join(counts, ", ")

Nos próximos capítulos você irá ver como adicionar segurança à sua API usando essas ferramentas disponibilizadas pelo **FastAPI**.