tests := []struct {
		name            string
		featuresEnabled []featuregate.Feature
	}{
		{
			name:            "enabled: UnknownVersionInteroperabilityProxy, disabled: StorageVersionAPI",
			featuresEnabled: []featuregate.Feature{features.UnknownVersionInteroperabilityProxy},
		},
	}

	for _, test := range tests {

}
func testWorkloadDefaults(t *testing.T, featuresEnabled bool) {
	allFeatures := utilfeature.DefaultFeatureGate.DeepCopy().GetAll()
	for feature, featureSpec := range allFeatures {
		if !featureSpec.LockToDefault {
			featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, feature, featuresEnabled)
		}
	}

				},
			},
			featureEnabled: true,
		},
		"empty user, SupplementalGroupsPolicy is enabled": {
			input:          &runtimeapi.ContainerUser{},
			expected:       &kubecontainer.ContainerUser{},
			featureEnabled: true,
		},
		"nil user, SupplementalGroupsPolicy is enabled": {
			input:          nil,
			expected:       nil,
			featureEnabled: true,
		},
	} {

	tests := []struct {
		name              string
		featureEnabled    bool
		seLinuxMountValue *bool
		expectError       bool
	}{{
		name:              "feature enabled, nil value",
		featureEnabled:    true,
		seLinuxMountValue: nil,
		expectError:       true,
	}, {
		name:              "feature enabled, non-nil value",
		featureEnabled:    true,
		seLinuxMountValue: utilpointer.Bool(true),

				},
			},
			featureEnabled: true,
		},
	}

	for i, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StructuredAuthorizationConfiguration, test.featureEnabled)

	featureEnabled := utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesSupport)

	if pod == nil || pod.Spec.HostUsers == nil {
		// if the feature is enabled, specify to use the node mode...
		if featureEnabled {
			return &runtimeapi.UserNamespace{
				Mode: runtimeapi.NamespaceMode_NODE,
			}, nil
		}

		obj            runtime.Object
		featureEnabled bool
		expectError    string
	}{
		"create allowed, enabled": {
			operation:      admission.Create,
			obj:            sliceNode,
			featureEnabled: true,
			expectError:    "",
		},
		"create disallowed, enabled": {
			operation:      admission.Create,
			obj:            sliceOtherNode,
			featureEnabled: true,
			expectError:    err,
		},

				},
			},
			featureEnabled: false,
			expectedErr:    `matchConditions: Invalid value: "": matchConditions are not supported when StructuredAuthorizationConfiguration feature gate is disabled`,
		},
		{
			name:            "no matchConditions should not require feature enablement",
			matchConditions: []api.WebhookMatchCondition{},
			featureEnabled:  false,
			expectedErr:     "",
		},
		{

		oldPodMeta                      *metav1.ObjectMeta
		featureEnabled                  bool
		wantAllowInvalidPodDeletionCost bool
	}{
		{
			name:                            "CreateFeatureEnabled",
			featureEnabled:                  true,
			wantAllowInvalidPodDeletionCost: false,
		},
		{
			name:                            "CreateFeatureDisabled",
			featureEnabled:                  false,

	kubelet := testKubelet.kubelet
	kubelet.statusManager = status.NewFakeManager()

	for tdesc, tc := range map[string]struct {
		testPodStatus           *kubecontainer.PodStatus
		featureEnabled          bool
		expectedContainerStatus []v1.ContainerStatus
	}{
		"nil user, SupplementalGroupsPolicy is disabled": {
			testPodStaus(nil),
			false,
			expectedContainerStatuses(nil),
		},