def get_enum_status_code():
    return "foo bar"


@app.get("/query/frozenset")
def get_query_type_frozenset(query: FrozenSet[int] = Query(...)):
    return ",".join(map(str, sorted(query)))


@app.get("/query/list")
def get_query_list(device_ids: List[int] = Query()) -> List[int]:
    return device_ids


@app.get("/query/list-default")

package schema

import (
	"bytes"
	"context"
	"database/sql"
	"database/sql/driver"
	"encoding/gob"
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"time"
)

var serializerMap = sync.Map{}

// RegisterSerializer register serializer
func RegisterSerializer(name string, serializer SerializerInterface) {
	serializerMap.Store(strings.ToLower(name), serializer)
}

// GetSerializer get serializer

				_, err = client.Kube().CoreV1().Pods("istio-system").Create(context.TODO(), &corev1.Pod{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "istiod-test",
						Namespace: "istio-system",
						Labels: map[string]string{
							"app":                 "istiod",
							label.IoIstioRev.Name: c.revision,
						},
					},
					Status: corev1.PodStatus{
						Phase: corev1.PodRunning,
					},

import com.google.common.collect.testing.features.Feature;
import com.google.common.collect.testing.features.ListFeature;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import junit.framework.TestSuite;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a {@code
 * ListMultimap} implementation.
 *

import static com.google.common.collect.testing.Helpers.mapEntry;

import com.google.common.annotations.GwtCompatible;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A container class for the five sample elements we need for testing.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible

        "-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",
        "-dev-?\\d+",
        "-dev-\\d+-\\d+",
        "-rc-?\\d+",
        "-M.+",
        "-eap-?\\d+"
    ).map { it.toRegex(RegexOption.IGNORE_CASE) }

    @get:Internal
    abstract val libraryVersionFile: RegularFileProperty

    @TaskAction
    fun updateInitPluginTemplateVersionFile() {

                if (os == Os.WINDOWS) {
                    listOf("jprofiler")
                } else {
                    listOf("async-profiler", "async-profiler-heap")
                }.map { FlameGraphGenerationBuildSpec(scenario, os, arch, it) }
            }
        }

    inner
    class FlameGraphGenerationBuildSpec(
        val performanceScenario: PerformanceScenario,

	}
}

var initialized = &sync.Once{}

func setup(t *testing.T) {
	initialized.Do(func() {
		// Setup group namespace so iptables --gid-owner will work
		assert.NoError(t, userns.WriteGroupMap(map[uint32]uint32{userns.OriginalGID(): 0}))
		// Istio iptables expects to find a non-localhost IP in some interface
		assert.NoError(t, exec.Command("ip", "addr", "add", "240.240.240.240/32", "dev", "lo").Run())

    CtClass oldBase
    CtClass newBase
    CtClass newSuper
    CtClass newIncubatingBase
    CtClass internalInterface
    CtClass incubatingInterface
    CtClass stablePublicInterface

    Map interfaces

    def setup() {
        rule = new IncubatingInternalInterfaceAddedRule(getInitializationParams())
        rule.context = context

        oldBase = instanceScopedPool.get(OldBase.name)

          request().withPath("/person")
            .withQueryStringParameter("name", "peter"),
        )
        .respond(response().withBody("Peter the person!"))

      val results =
        (1..20).map {
          executor.submit {
            val response =
              client.newCall(Request((mockServer.secureEndpoint + "/person?name=peter").toHttpUrl())).execute()

            val body = response.body.string()