// perform the API call immediately.
		if deadline <= 0 {
			globalHTTPStats.addRequestsInQueue(-1)
			f.ServeHTTP(w, r)
			return
		}

		if tc, ok := r.Context().Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt); ok {
			tc.FuncName = "s3.MaxClients"
		}

		deadlineTimer := time.NewTimer(deadline)
		defer deadlineTimer.Stop()

		ctx := r.Context()
		select {

	requireLocalIstiod        bool
	requireSingleNetwork      bool
	minIstioVersion           string
	minKubernetesMinorVersion uint
	topLevel                  bool

	ctx *testContext
	tc  context2.Context
	ts  traceapi.Span
}

// NewTest returns a new test wrapper for running a single test.
func NewTest(t *testing.T) Test {
	rtMu.Lock()
	defer rtMu.Unlock()

	if rt == nil {

	return 0
}

func (s *suiteImpl) run() (errLevel int) {
	tc, shutdown, err := tracing.InitializeFullBinary(s.testID)
	if err != nil {
		return 99
	}
	defer shutdown()
	if err := initRuntime(s); err != nil {
		scopes.Framework.Errorf("Error during test framework init: %v", err)
		return exitCodeInitError
	}
	rt.context.traceContext = tc

	ctx := rt.suiteContext()
	// Skip the test if its explicitly skipped

		{disableKeepAlives: true, close: true},
	}

	for _, tc := range tests {
		t.Run(fmt.Sprintf("DisableKeepAlive=%v,RequestClose=%v", tc.disableKeepAlives, tc.close),
			func(t *testing.T) {
				ts := newClientServerTest(t, mode, hostPortHandler).ts

				c := ts.Client()
				c.Transport.(*Transport).DisableKeepAlives = tc.disableKeepAlives
				req, err := NewRequest("GET", ts.URL, nil)
				if err != nil {

	gatherers := prometheus.Gatherers{
		registry,
	}

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		tc, ok := r.Context().Value(mcontext.ContextTraceKey).(*mcontext.TraceCtxt)
		if ok {
			tc.FuncName = funcName
			tc.ResponseRecorder.LogErrBody = true
		}

		mfs, err := gatherers.Gather()
		if err != nil && len(mfs) == 0 {

  - name: auto
    port: 81
  - name: tcp
    port: 82
  - name: tls
    port: 83
  - name: https
    port: 84`

	type tc struct {
		call     simulation.Call
		expected string
	}
	calls := []simulation.Expect{}
	for _, call := range []tc{
		{call: simulation.Call{Address: "1.2.3.4", Port: 80, Protocol: simulation.HTTP, HostHeader: "alias.default.svc.cluster.local"}, expected: "alias"},

			requestRV:        "0",
			expectResponseRV: secondNonConsistentReadRV,
		},
	}
	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			out := &example.PodList{}
			opts := storage.ListOptions{
				ResourceVersion: tc.requestRV,
				Predicate:       storage.Everything,
			}
			err = store.GetList(ctx, "/pods/empty", opts, out)
			if err != nil {

		{"/foo%2Fbar/qux", "", ""}, // Escaped prefix does not match.
		{"/bar", "", ""},           // No prefix match.
	}
	for _, tc := range cases {
		t.Run(tc.reqPath, func(t *testing.T) {
			res, err := c.Get(ts.URL + tc.reqPath)
			if err != nil {
				t.Fatal(err)
			}
			res.Body.Close()
			if tc.path == "" {
				if res.StatusCode != StatusNotFound {
					t.Errorf("got %q, want 404 Not Found", res.Status)
				}

		if err != nil {
			return nil, wrapErr(err)
		}
		if tc, ok := pconn.conn.(*tls.Conn); ok {
			// Handshake here, in case DialTLS didn't. TLSNextProto below
			// depends on it for knowing the connection state.
			if trace != nil && trace.TLSHandshakeStart != nil {
				trace.TLSHandshakeStart()
			}
			if err := tc.HandshakeContext(ctx); err != nil {
				go pconn.conn.Close()