And that function `get_openapi()` receives as parameters:

* `title`: The OpenAPI title, shown in the docs.
* `version`: The version of your API, e.g. `2.5.0`.
* `openapi_version`: The version of the OpenAPI specification used. By default, the latest: `3.1.0`.
* `summary`: A short summary of the API.

//
//	if _, _, err = c.ReadCodeLine(110); err != nil {
//		return nil, err
//	}
//	text, err := c.ReadDotBytes()
//	if err != nil {
//		return nil, err
//	}
//	return c.ReadCodeLine(250)
func (c *Conn) Cmd(format string, args ...any) (id uint, err error) {
	id = c.Next()
	c.StartRequest(id)
	err = c.PrintfLine(format, args...)
	c.EndRequest(id)
	if err != nil {
		return 0, err
	}

    private boolean configurationCacheQuiet;
    private boolean searchUpwards = true;
    private boolean useEmptySettings = false;
    private Duration continuousBuildQuietPeriod = Duration.ofMillis(250);

    public StartParameterInternal() {
    }

    protected StartParameterInternal(BuildLayoutParameters layoutParameters) {
        super(layoutParameters);
    }

    @Override

golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

    }

    def "includes execution time of project evaluation listener callbacks"() {
        given:
        def sleepMillis = 250
        file("build.gradle") << """
            apply plugin: MyPlugin
            class MyPlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.afterEvaluate {

	"istio.io/istio/pkg/slices"
)

// Set is an immutable set optimized for *small number of items*. For general purposes, Sets is likely better
//
// *Set construction*: sets is roughly 1kb allocations per 250 items. smallsets is 0.
// *Contains* sets is O(1). smallsets is O(logn). smallsets is typically faster up to about 5 elements.
//
//	At 1000 items, it is roughly 5x slower (30ns vs 5ns).
type Set[T constraints.Ordered] struct {

        .testChangeFile(450, 2250, 45000).create()),
    LARGE_JAVA_MULTI_PROJECT_HIERARCHY(new TestProjectGeneratorConfigurationBuilder("largeJavaMultiProjectHierarchy")
        .withSourceFiles(100)
        .withSubProjects(250)
        .withProjectDepth(5)
        .withDaemonMemory('2g')
        .withCompilerMemory('512m')
        .assembleChangeFile()
        .testChangeFile(450, 2250, 45000).create()),

		tracker.ObservedPodOnWatch(podStarted, frozenTime.Add(time.Second*150))
		tracker.ObservedPodOnWatch(podStarted, frozenTime.Add(time.Second*200))
		tracker.ObservedPodOnWatch(podStarted, frozenTime.Add(time.Second*250))

		if err := testutil.GatherAndCompare(metrics.GetGather(), strings.NewReader(wants), metricsName); err != nil {
			t.Fatal(err)
		}

		// cleanup
		tracker.DeletePodStartupState(podStarted.UID)

        if (TestPrecondition.satisfied(UnitTestPreconditions.MacOs) && TestPrecondition.notSatisfied(UnitTestPreconditions.MacOsM1)) {
            def quietPeriod = 250
            waitAtEndOfBuildForQuietPeriod(quietPeriod)
        }
    }

    def "changes to upstream project triggers build of downstream"() {
        expect:
        succeeds "build"

			go func() {
				time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
				c.Close()
				Println("closed dial")
			}()
		}
		// Don't run out of ephemeral ports too quickly:
		time.Sleep(250 * time.Millisecond)
	}
}

func stressNet() {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		size, _ := strconv.Atoi(r.FormValue("size"))
		w.Write(make([]byte, size))