import os
from pathlib import Path

import pytest
from fastapi.testclient import TestClient


@pytest.fixture(scope="module")
def client():
    static_dir: Path = Path(os.getcwd()) / "static"
    print(static_dir)
    static_dir.mkdir(exist_ok=True)
    from docs_src.custom_docs_ui.tutorial001 import app

    with TestClient(app) as client:
        yield client
    static_dir.rmdir()

)

// Start opens the counter files for writing if telemetry is supported
// on the current platform (and does nothing otherwise).
func Start() {
	telemetry.Start(telemetry.Config{
		TelemetryDir: os.Getenv("TEST_TELEMETRY_DIR"),
	})
}

// StartWithUpload opens the counter files for writing if telemetry
// is supported on the current platform and also enables a once a day

import spock.lang.Specification

class DefaultBuildActionParametersTest extends Specification {

    def "is serializable"() {
        given:
        def params = new DefaultBuildActionParameters(System.properties, System.getenv(), new File("."), LogLevel.ERROR, true, ClassPath.EMPTY)
        ObjectOutputStream out = new ObjectOutputStream(new ByteArrayOutputStream());

        when:
        out.writeObject(params);

        then:

    private final Kind kind;
    private final int index;

    NestedExceptionPlaceholder(Kind kind, int index) {
        this.kind = kind;
        this.index = index;
    }

    public Kind getKind() {
        return kind;
    }

    public int getIndex() {
        return index;
    }

    enum Kind {
        cause,
        suppressed
    }

			targetRef.GetKind() == gvk.KubernetesGateway.Kind &&
			target.Name == gatewayName &&
			(targetRef.GetNamespace() == "" || targetRef.GetNamespace() == p.Namespace) {
			return true
		}

		// Service attached
		if p.IsWaypoint &&
			config.CanonicalGroup(targetRef.GetGroup()) == gvk.Service.CanonicalGroup() &&
			targetRef.GetKind() == gvk.Service.Kind &&

        }
    }

    @Nullable
    private InetAddress findOpenshiftAddresses() {
        for (String key : System.getenv().keySet()) {
            if (key.startsWith("OPENSHIFT_") && key.endsWith("_IP")) {
                String ipAddress = System.getenv(key);
                logger.debug("OPENSHIFT IP environment variable {} detected. Using IP address {}.", key, ipAddress);
                try {

import "fmt"

func main() {
        n, err := fmt.Println(1)
}
`)
	f.Close()
	defer os.RemoveAll(f.Name())

	// compile and test output
	cmd := exec.Command("go", "tool", "compile", "-p=main", "-importcfg="+os.Getenv("STDLIB_IMPORTCFG"), f.Name())
	out, err := cmd.CombinedOutput()
	if err == nil {
		log.Fatalf("expected cmd/compile to fail")
	}
	wantErrs := []string{
		"7:9: declared and not used: n",

	// check http route match requests
	errs = AppendValidation(errs, validateHTTPRouteMatchRequest(http))

	// header manipulation
	for name, val := range http.Headers.GetRequest().GetAdd() {
		errs = AppendValidation(errs, ValidateHTTPHeaderWithAuthorityOperationName(name))
		errs = AppendValidation(errs, ValidateHTTPHeaderValue(val))
	}
	for name, val := range http.Headers.GetRequest().GetSet() {

        // We can't "unset" the variable with the API executer provides, but it isn't necessary, thanks to the filtering in
        // build-logic/jvm/src/main/kotlin/gradlebuild/propagated-env-variables.kt
        if (System.getenv().containsKey(key)) {
            throw new IllegalStateException("Environment variable $key is present for this process and may affect tests")
        }
    }

import os
from typing import Any, Dict, List

from pdm.backend.hooks import Context

TIANGOLO_BUILD_PACKAGE = os.getenv("TIANGOLO_BUILD_PACKAGE", "fastapi")


def pdm_build_initialize(context: Context) -> None:
    metadata = context.config.metadata
    # Get custom config for the current package, from the env var
    config: Dict[str, Any] = context.config.data["tool"]["tiangolo"][
        "_internal-slim-build"