for i, action := range actions {
				if len(tc.ExpectedActions) < i+1 {
					t.Errorf("%s: %d unexpected actions: %+v", k, len(actions)-len(tc.ExpectedActions), actions[i:])
					break
				}

				expectedAction := tc.ExpectedActions[i]
				if !reflect.DeepEqual(expectedAction, action) {
					t.Errorf("%s:\nExpected:\n%s\ngot:\n%s", k, dump.Pretty(expectedAction), dump.Pretty(action))
					continue
				}
			}

		nextCreateAt      []time.Time
		clientObjects     []runtime.Object
		existingConfigMap *corev1.ConfigMap

		expectedErr     error
		expectedActions []core.Action
	}{
		{
			name:          "create configmap [no cache, no live object]",
			clientObjects: []runtime.Object{},
			expectedActions: []core.Action{

		}
		actions := client.Actions()
		for i, action := range actions {
			if len(test.expectedActions) < i+1 {
				t.Errorf("Test %q: %d unexpected actions: %+v", test.name, len(actions)-len(test.expectedActions), dump.Pretty(actions[i:]))
				break
			}

			expectedAction := test.expectedActions[i]
			if !reflect.DeepEqual(expectedAction, action) {

			if len(actions) != len(tc.ExpectedActions) {
				t.Fatalf("got %d actions, wanted %d actions", len(actions), len(tc.ExpectedActions))
			}
			for i, action := range actions {
				if len(tc.ExpectedActions) < i+1 {
					t.Errorf("%s: %d unexpected actions: %+v", k, len(actions)-len(tc.ExpectedActions), actions[i:])
					break
				}
				expectedAction := tc.ExpectedActions[i]

	}

	for i, action := range actual {
		expectedAction := expected[i]
		verb := expectedAction.GetVerb()
		resource := expectedAction.GetResource().Resource
		if !action.Matches(verb, resource) {
			return fmt.Errorf("unexpected %dth action, want \n%+v but got \n%+v\n%v", i, expectedAction, action, cmp.Diff(expectedAction, action))
		}
	}

	return nil
}

		updatedPV *v1.PersistentVolume
		// List of expected kubeclient actions that should happen during the
		// test.
		expectedActions []clienttesting.Action
	}{
		// PV events
		//
		{
			name:      "PV without finalizer -> finalizer is added",
			updatedPV: pv(),
			expectedActions: []clienttesting.Action{
				clienttesting.NewUpdateAction(pvVer, "", withProtectionFinalizer(pv())),
			},
		},
		{

			}

			actions := client.Actions()
			if len(actions) != len(tc.expectedActions) {
				t.Fatalf("got %d actions, wanted %d actions", len(actions), len(tc.expectedActions))
			}
			for i := 0; i < len(actions); i++ {
				if a := actions[i]; !a.Matches(tc.expectedActions[i], "certificatesigningrequests") {
					t.Errorf("got action %#v, wanted %v", a, tc.expectedActions[i])
				}
			}
		})
	}

				"/apis/foo-group/foo-version/namespaces/{namespace}/foos":               {expectNamespaceParam: true, expectNameParam: false, expectedActions: sets.NewString("post", "list", "deletecollection")},
				"/apis/foo-group/foo-version/namespaces/{namespace}/foos/{name}":        {expectNamespaceParam: true, expectNameParam: true, expectedActions: sets.NewString("get", "put", "patch", "delete")},

					if len(fakeClient.Actions()) != 0 {
						t.Fatalf("unexpected actions %#v", fakeClient.Actions())
					}
					return
				}

				expectedActions := 1
				if !serverSideApplyEnabled {
					expectedActions = 2
				}
				if len(fakeClient.Actions()) != expectedActions {
					t.Fatalf("unexpected actions %#v", fakeClient.Actions())
				}

				action := fakeClient.Actions()[0]

				return
			}

			// patch, then patch, get, patch, get, patch, ... up to initial patch + nodeStatusUpdateRetry patches
			expectedActions := 2*tc.wantPatches - 2
			if tc.wantPatches == 1 {
				expectedActions = 1
			}
			require.Len(t, actions, expectedActions)

			for i, action := range actions {
				if i%2 == 0 && i > 0 {
					require.IsType(t, core.GetActionImpl{}, action)
					continue