return
	}

	tc.queue.AddAfter(key, after)
}

func (tc *Controller) worker(ctx context.Context) {
	for tc.processNextWorkItem(ctx) {
	}
}

func (tc *Controller) processNextWorkItem(ctx context.Context) bool {
	key, quit := tc.queue.Get()
	if quit {
		return false
	}
	defer tc.queue.Done(key)

	err := tc.processJob(ctx, key)
	tc.handleErr(err, key)

	return true
}

	if err := AddToScheme(scheme); err != nil {
		t.Fatal(err)
	}

	for k, tc := range testCases {
		external := &JSONSchemaProps{}
		if err := scheme.Convert(tc.input, external, nil); err != nil {
			t.Errorf("%s: unexpected error: %v", k, err)
		}

		if !reflect.DeepEqual(external, tc.expected) {
			t.Errorf("%s: expected\n\t%#v, got \n\t%#v", k, tc.expected, external)
		}
	}
}

		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			gotOld, gotNew, err := As[*v1.Pod](tc.oldObj, tc.newObj)
			if err != nil && !tc.wantErr {
				t.Fatalf("unexpected error: %v", err)
			}
			if tc.wantErr {
				if err == nil {
					t.Fatalf("expected error, but got nil")
				}
				return
			}

			if diff := cmp.Diff(tc.wantOldObj, gotOld); diff != "" {

	}

func TestPathToPrefix(t *testing.T) {
	for _, tc := range escapeTests {
		if got := PathToPrefix(tc.Path); got != tc.Escaped {
			t.Errorf("expected PathToPrefix(%s) = %s, got %s", tc.Path, tc.Escaped, got)
		}
	}
}

func TestPrefixToPath(t *testing.T) {
	for _, tc := range escapeTests {
		got, err := PrefixToPath(tc.Escaped)
		if err != nil {

		expectedNumSlices:  1,
	}}

	for _, tc := range testCases {
		t.Run(tc.testName, func(t *testing.T) {
			_, ctx := ktesting.NewTestContext(t)
			client, esController := newController(ctx, time.Duration(0))
			tc.endpoints.Name = endpointsName
			tc.endpoints.Namespace = namespace
			esController.endpointsStore.Add(tc.endpoints)
			if tc.service != nil {
				tc.service.Name = endpointsName

		t.Errorf("failed reading index %s (%s)", tc.name, err)
	}
	if !equal(x, &y) {
		t.Errorf("restored index doesn't match saved index %s", tc.name)
	}

	return size
}

func testIndex(t *testing.T) {
	for _, tc := range testCases {
		x := New([]byte(tc.source))
		testConstruction(t, &tc, x)
		testSaveRestore(t, &tc, x)
		testLookups(t, &tc, x, 0)
		testLookups(t, &tc, x, 1)
		testLookups(t, &tc, x, 10)

			exitError:  transientError,
		},
	}

	for _, tc := range tests {
		metricsGetter := &metricsCsi{volumeID: tc.volumeID, targetPath: tc.targetPath}
		metricsGetter.driverName = "unknown-driver"
		_, err := metricsGetter.GetMetrics()
		if err == nil {
			t.Errorf("test should fail, but no error occurred")
		} else if reflect.TypeOf(tc.exitError) != reflect.TypeOf(err) {

			}
			if tc.UpdatedServiceAccount != nil {
				serviceAccounts.Add(tc.UpdatedServiceAccount)
				controller.queueServiceAccountUpdateSync(nil, tc.UpdatedServiceAccount)
			}
			if tc.DeletedServiceAccount != nil {
				serviceAccounts.Delete(tc.DeletedServiceAccount)
				controller.queueServiceAccountSync(tc.DeletedServiceAccount)
			}
			if tc.AddedSecret != nil {
				secrets.Add(tc.AddedSecret)

				Conditions:      commonVersionFalseCondition(),
			},
		},
	}

	for _, tc := range tests {
		sv := &v1alpha1.StorageVersion{Status: tc.old}
		updated := localUpdateStorageVersion(sv, tc.newSSV.APIServerID, tc.newSSV.EncodingVersion, tc.newSSV.DecodableVersions, tc.newSSV.ServedVersions)
		if tc.expectLastTransitionTimeUpdate == updated.Status.Conditions[0].LastTransitionTime.IsZero() {

			t.Errorf("%q: Did not observe an expected error", tc.desc)
			continue
		}
		if !tc.expectErr && err != nil {
			t.Errorf("%q: Observed an unexpected error: %v", tc.desc, err)
			continue
		}
		if tc.expectVal != ipport {
			t.Errorf("%q: Unexpected ipport: expected %q, saw %q", tc.desc, tc.expectVal, ipport)
		}
	}
}

func TestReservedMemoryVar(t *testing.T) {