statusCode int
		object     runtime.Object

		wantCode    int
		wantHeaders http.Header
		wantBody    []byte
	}{
		{
			name:        "serialize object",
			out:         smallPayload,
			req:         &http.Request{Header: http.Header{}, URL: &url.URL{Path: "/path"}},
			wantCode:    http.StatusOK,
			wantHeaders: http.Header{"Content-Type": []string{""}},
			wantBody:    smallPayload,
		},

		{

					for _, c := range cases {
						c := c
						testName := fmt.Sprintf("%s(%s)/http", c.host, c.allow)
						t.NewSubTest(testName).Run(func(t framework.TestContext) {
							wantCode := http.StatusOK
							if !c.allow {
								wantCode = http.StatusForbidden
							}

							opts := echo.CallOptions{
								Port: echo.Port{
									Protocol: protocol.HTTP,
								},
								HTTP: echo.HTTP{

	tests := []struct {
		name           string
		wantCode       int
		errorHandler   func(http.ResponseWriter, *http.Request, error)
		transport      http.RoundTripper // defaults to failingRoundTripper
		modifyResponse func(*http.Response) error
	}{
		{
			name:     "default",
			wantCode: http.StatusBadGateway,
		},
		{
			name:         "errorhandler",
			wantCode:     http.StatusTeapot,

		}
		body, err := io.ReadAll(res.Body)
		res.Body.Close()
		if err != nil {
			t.Fatal(err)
		}
		wantBody := file
		if method == MethodHead {
			wantBody = nil
		}
		if !bytes.Equal(body, wantBody) {
			t.Fatalf("%v: got body %q, want %q", method, body, wantBody)
		}
		if got, want := res.Header.Get("Content-Length"), fmt.Sprint(len(file)); got != want {

	c := &Client{Transport: tr}

	testResponse := func(req *Request, name string, wantCode int) {
		t.Helper()
		res, err := c.Do(req)
		if err != nil {
			t.Fatalf("%s: Do: %v", name, err)
		}
		if res.StatusCode != wantCode {
			t.Fatalf("%s: Response Statuscode=%d; want %d", name, res.StatusCode, wantCode)
		}

	dt := newTransportDialTester(t, http1Mode)

	// First request creates a new connection.
	rt1 := dt.roundTrip()
	c1 := dt.wantDial()
	c1.finish(nil)
	rt1.wantDone(c1)
	rt1.finish()

	// Second request reuses the first connection.
	rt2 := dt.roundTrip()
	rt2.wantDone(c1)
	rt2.finish()
}

func TestTransportPoolConnCannotReuseConnectionInUse(t *testing.T) {
	dt := newTransportDialTester(t, http1Mode)

				t.Errorf("Unexpected error: %v", errs.ToAggregate())
			}

			Strategy.PrepareForCreate(genericapirequest.NewContext(), pod)
			wantPod.Spec.TopologySpreadConstraints = append(wantPod.Spec.TopologySpreadConstraints, tc.wantTopologySpreadConstraints...)
			if diff := cmp.Diff(wantPod, pod, cmpopts.IgnoreFields(pod.Status, "Phase", "QOSClass")); diff != "" {
				t.Errorf("%s unexpected result (-want, +got): %s", tc.name, diff)
			}
		})

		newPod      *api.Pod
		wantPod     *api.Pod
	}{
		{
			description: "old with claims / new with claims / disabled",
			oldPod:      podWithClaims,
			newPod:      podWithClaims,
			wantPod:     podWithClaims,
		},
		{
			description: "old without claims / new with claims / disabled",
			oldPod:      podWithoutClaims,
			newPod:      podWithClaims,
			wantPod:     podWithoutClaims,
		},
		{

	tests := []struct {
		name                                string
		old, update                         *storage.CSIDriver
		seLinuxMountReadWriteOncePodEnabled bool
		wantCapacity                        *bool
		wantModes                           []storage.VolumeLifecycleMode
		wantTokenRequests                   []storage.TokenRequest
		wantRequiresRepublish               *bool
		wantGeneration                      int64

					if diff := cmp.Diff(wantFitErr, gotFitErr); diff != "" {
						t.Errorf("Unexpected fitErr: (-want, +got): %s", diff)
					}
				}
			}
			if test.wantNodes != nil && !test.wantNodes.Has(result.SuggestedHost) {
				t.Errorf("Expected: %s, got: %s", test.wantNodes, result.SuggestedHost)
			}
			wantEvaluatedNodes := len(test.nodes)
			if test.wantEvaluatedNodes != nil {
				wantEvaluatedNodes = int(*test.wantEvaluatedNodes)