config        *kubeadmapi.InitConfiguration
		expectedCerts []string
	}{
		"local etcd": {
			config: localEtcdCfg,
			expectedCerts: append(
				[]string{kubeadmconstants.EtcdCACertName, kubeadmconstants.EtcdCAKeyName},
				commonExpectedCerts...,
			),
		},
		"external etcd": {
			config: externalEtcdCfg,
			expectedCerts: append(
				[]string{externalEtcdCA, externalEtcdCert, externalEtcdKey},

			}
		})
	}
}

func TestUnmarshalYAML(t *testing.T) {
	v := &Version{}
	expectedErr := fmt.Errorf("test error")
	errReturn := func(any) error { return expectedErr }
	gotErr := v.UnmarshalYAML(errReturn)
	if gotErr == nil {
		t.Errorf("expected error but got nil")
	}
	if gotErr != expectedErr {
		t.Errorf("error mismatch")
	}

		{statusCode: 500, expectedErr: true, expectedAuthorized: false, expectedCached: false},
		{statusCode: 404, expectedErr: true, expectedAuthorized: false, expectedCached: false},
		{statusCode: 403, expectedErr: true, expectedAuthorized: false, expectedCached: false},
		{statusCode: 401, expectedErr: true, expectedAuthorized: false, expectedCached: false},

	testcases := map[string]struct {
		pod            *v1.Pod
		oldObj, newObj interface{}
		expectedHint   framework.QueueingHint
		expectedErr    bool
	}{
		"backoff-wrong-new-object": {
			pod:          &v1.Pod{},
			newObj:       "not-a-pod",
			expectedHint: framework.Queue,
			expectedErr:  true,
		},
		"backoff-wrong-old-object": {
			pod:          &v1.Pod{},
			oldObj:       "not-a-pod",

			pod:           "not a pod object",
			expectedValue: "test-pod",
			expectedErr:   fmt.Errorf("not a pod"),
		},
	}

	for _, tc := range tcs {
		indexValues, err := tc.indexFunc(tc.pod)
		if !reflect.DeepEqual(err, tc.expectedErr) {
			t.Errorf("name %v, expected %v, got %v", tc.name, tc.expectedErr, err)
		}
		if err == nil && len(indexValues) != 1 && indexValues[0] != tc.expectedValue {

			if tt.isNotNil {
				assert.Nil(t, actualErr)
				assert.NotNil(t, actualBytes)
			} else {
				if tt.expectedErr != nil {
					assert.Equal(t, tt.expectedErr, actualErr)
				} else {
					assert.Error(t, actualErr)
				}
				assert.Nil(t, actualBytes)
			}

			assert.Equal(t, tt.count, i)
		})
	}
}

		pod:            newSupplementalGroupsPolicyPod(&supplementalGroupsPolicyUnSupported),
		expectedErr:    true,
		expectedErrMsg: "unsupported supplementalGroupsPolicy: UnSupported",
	},
	}

	for i, test := range tests {
		config, err := m.generatePodSandboxLinuxConfig(test.pod)
		if test.expectedErr {
			assert.NotEmptyf(t, err, "TestCase[%d]: %s", i, test.description)

					t.Errorf("expected %d errors but got %d errors", len(tc.expectErrors), len(errs))
					return
				}
				for i, expectedErr := range tc.expectErrors {
					if expectedErr != errs[i].Error() {
						t.Errorf("expected error '%s' but got '%s'", expectedErr, errs[i].Error())
					}
				}
				return
			}
			if len(errs) != 0 {
				t.Errorf("expected no errors, but got: %v", errs)
			}

		{
			vol:          newtierfi.Volume,
			name:         newtierfi.Name,
			inclFreeVers: false,
			expectedErr:  errFileNotFound,
		},
	}

	for _, ft := range freeVersionsTests {
		fi, err := xl.ToFileInfo(ft.vol, ft.name, "", ft.inclFreeVers, true)
		if err != nil && !errors.Is(err, ft.expectedErr) {
			t.Fatalf("ToFileInfo failed due to %v", err)
		}
		if got := fi.TierFreeVersion(); got != ft.expectedFree {

	testcases := map[string]struct {
		pod          *v1.Pod
		oldObj       interface{}
		expectedHint framework.QueueingHint
		expectedErr  bool
	}{
		"backoff-wrong-old-object": {
			pod:          podWithHostPort.Obj(),
			oldObj:       "not-a-pod",
			expectedHint: framework.Queue,
			expectedErr:  true,
		},
		"skip-queue-on-unscheduled": {
			pod:          podWithHostPort.Obj(),
			oldObj:       st.MakePod().Obj(),