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

	//
	// "c" and "b" could be in either order, but Topo is
	// deterministic in reverse node definition order.
	//
	// "a" is a leaf.
	wantNodes := strings.Fields("d c b a")
	if !reflect.DeepEqual(wantNodes, got) {
		t.Fatalf("want topo sort %v, got %v", wantNodes, got)
	}
}

func TestTransitiveReduction(t *testing.T) {
	t.Run("diamond", func(t *testing.T) {
		g := mustParse(t, diamond)
		g.TransitiveReduction()

			}
		}
	}
}

func TestParse(t *testing.T) {
	// Basic smoke test for graph parsing.
	g := mustParse(t, diamond)

	wantNodes := strings.Fields("a b c d")
	if !reflect.DeepEqual(wantNodes, g.Nodes) {
		t.Fatalf("want nodes %v, got %v", wantNodes, g.Nodes)
	}

	// Parse returns the transitive closure, so it adds d->a.
	wantEdges(t, g, "b->a c->a d->a d->b d->c")

		object     runtime.Object

		wantCode    int
		wantHeaders http.Header
	}
	newTest := func() test {
		return test{
			name:      "compress on gzip",
			out:       largePayload,
			mediaType: "application/json",
			req: &http.Request{
				Header: http.Header{
					"Accept-Encoding": []string{"gzip"},
				},
				URL: &url.URL{Path: "/path"},
			},
			wantCode: http.StatusOK,
			wantHeaders: http.Header{

	tests := []struct {
		name     string
		wantCode int
		proxyID  string
	}{
		{
			name:     "dumps most recent proxy with 200",
			proxyID:  "test.default",
			wantCode: 200,
		},
		{
			name:     "returns 404 if proxy not found",
			proxyID:  "not-found",
			wantCode: 404,
		},
		{
			name:     "returns 400 if no proxyID",
			proxyID:  "",
			wantCode: 400,
		},
	}

	analyze.AnalyzerFoundIssuesError{}:                             ExitAnalyzerFoundIssues,
}

func TestKnownExitStrings(t *testing.T) {
	for err, wantCode := range KnownErrorCode {
		if code := GetExitCode(err); code != wantCode {
			t.Errorf("For %v want %v, but is %v", err, wantCode, code)
		}
	}

			Data:    nil,
			Mode:    os.ModeDir,
			ModTime: time.Now(),
			Sys:     &sysValue,
		},
	}

	tests := []struct {
		path     string
		wantMode FileMode
		wantDir  bool
	}{
		{path: "notadir.txt", wantMode: 0, wantDir: false},
		{path: "adir", wantMode: os.ModeDir, wantDir: true},
	}

	for _, test := range tests {
		test := test
		t.Run(test.path, func(t *testing.T) {
			fi, err := Stat(testFs, test.path)

			}
		})
	}
}

func TestDeletePods(t *testing.T) {
	tests := []struct {
		name      string
		client    kube.Client
		config    config.RepairConfig
		wantErr   bool
		wantPods  []*corev1.Pod
		wantCount float64
		wantTags  map[string]string
	}{
		{
			name:   "No broken pods",
			client: fakeClient(workingPod, workingPodDiedPreviously),
			config: config.RepairConfig{

	type checkFunc func(*ResponseRecorder) error
	check := func(fns ...checkFunc) []checkFunc { return fns }

	hasStatus := func(wantCode int) checkFunc {
		return func(rec *ResponseRecorder) error {
			if rec.Code != wantCode {
				return fmt.Errorf("Status = %d; want %d", rec.Code, wantCode)
			}
			return nil
		}
	}
	hasResultStatus := func(want string) checkFunc {
		return func(rec *ResponseRecorder) error {

					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)