scheme      *runtime.Scheme
		errExpected field.ErrorList
	}{
		{
			name:        "v1, create, zero value, no error expected",
			obj:         v1ObjFn(ptr.To(int32(0))),
			scheme:      v1SchemeFn(t),
			errExpected: nil,
		},
		{
			name:        "v1, create, unset, no error expected",
			obj:         v1ObjFn(nil),
			scheme:      v1SchemeFn(t),
			errExpected: nil,
		},
		{

			callback: func(_ int) (bool, error) {
				return true, conditionErr
			},
			attemptsExpected: 1,
			errExpected:      conditionErr,
		},
		{
			name: "condition exits after an error",
			callback: func(_ int) (bool, error) {
				return false, conditionErr
			},
			attemptsExpected: 1,
			errExpected:      conditionErr,
		},
		{
			name:             "context already canceled no attempts expected",

		callback           func(calls int) (bool, error)
		cancelContextAfter int
		attemptsExpected   int
		errExpected        error
	}{
		{
			name:             "no attempts expected with zero backoff steps",
			steps:            0,
			callback:         defaultCallback,
			attemptsExpected: 0,
			errExpected:      ErrWaitTimeout,
		},
		{
			name:             "condition returns false with single backoff step",

			},
			output:      doNothing,
			errExpected: false,
		},
		{
			name:        "invalid syntax, passing nil",
			template:    invalidTmpl1,
			data:        nil,
			output:      "",
			errExpected: true,
		},
		{
			name:        "invalid syntax",
			template:    invalidTmpl2,
			data:        struct{}{},
			output:      "",
			errExpected: true,
		},
	}
	for _, tt := range tmplTests {

				t.Errorf("failed TestGetAvailableUpgrades\n\texpected upgrades:\n%v\n\tgot:\n%v\n\tdiff:\n%v", rt.expectedUpgrades, actualUpgrades, diff)
			}
			if rt.errExpected && actualErr == nil {
				t.Error("unexpected success")
			} else if !rt.errExpected && actualErr != nil {
				t.Errorf("unexpected failure: %v", actualErr)
			}
			if diff := cmp.Diff(rt.expectedUpgrades, actualUpgrades); len(diff) > 0 {

	fi, err := getStat(event)
	fiExpected, errExpected := os.Stat(event.Name)
	// TODO: This is a workaround for Windows 20H2 issue for os.Stat(). Please see
	// microsoft/Windows-Containers#97 for details.
	// Once the issue is resvolved, the following os.Lstat() is not needed.
	if errExpected != nil {
		fiExpected, errExpected = os.Lstat(event.Name)
	}

	assert.Equal(t, fi, fiExpected)

		name          string
		lastUpdated   time.Duration
		count         int64
		errExpected   error
		countExpected int64
	}{
		{
			name:        "object count not tracked for given resource",
			count:       -2,
			errExpected: ObjectCountNotFoundErr,
		},
		{
			name:        "transient failure",
			count:       -1,
			errExpected: ObjectCountNotFoundErr,
		},
		{
			name:          "object count is zero",

	tests := []struct {
		name        string
		sources     []string
		errExpected bool
		sourcesLen  int
	}{
		{
			name:        "empty source",
			sources:     []string{""},
			errExpected: false,
			sourcesLen:  0,
		},
		{
			name:        "file and apiserver source",
			sources:     []string{FileSource, ApiserverSource},
			errExpected: false,
			sourcesLen:  2,
		},
		{
			name:        "all source",

		rs, err := parseRequestRangeSpec(testCase.spec)
		if err != nil {
			if !testCase.errExpected || err == nil && testCase.errExpected {
				t.Errorf("unexpected err: %v", err)
			}
			continue
		}
		h, err := rs.ToHeader()
		if err != nil && !testCase.errExpected || err == nil && testCase.errExpected {
			t.Errorf("expected error with invalid range: %v", err)
		}
		if h != testCase.spec {

		borrowingLimitPercent *int32
		errExpected           field.ErrorList
	}{{
		lendablePercent: nil,
		errExpected:     nil,
	}, {
		lendablePercent: pointer.Int32(0),
		errExpected:     nil,
	}, {
		lendablePercent: pointer.Int32(100),
		errExpected:     nil,
	}, {
		lendablePercent: pointer.Int32(101),
		errExpected:     errLendablePercentFn(101),
	}, {