},
			clientSetup: func(clientset *clientsetfake.Clientset) {
				clientset.PrependReactor("list", "pods", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
					return true, nil, apierrors.NewInternalError(errors.New("API server down"))
				})
			},
			expectedErr: true,
		},
	}
	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			client := clientsetfake.NewSimpleClientset()

	}{
		{
			name:        "no newFunc provided",
			setupFn:     func(opts *setupOptions) { opts.newFunc = nil },
			requestOpts: storage.ListOptions{ProgressNotify: true},
			expectedErr: apierrors.NewInternalError(errors.New("progressNotify for watch is unsupported by the etcd storage because no newFunc was provided")),
		},
	}
	for _, scenario := range scenarios {
		t.Run(scenario.name, func(t *testing.T) {

			}

			// VersionedAttr result will be cached and reused later during parallel
			// hook calls
			_, err = versionedAttrAccessor.VersionedAttribute(matchGVK)
			if err != nil {
				return apierrors.NewInternalError(err)
			}
		}

	}

	if len(relevantHooks) == 0 {
		// no matching hooks
		return nil
	}

	return d.delegate(ctx, a, o, versionedAttrAccessor, relevantHooks)
}

						node = &api.Node{ObjectMeta: metav1.ObjectMeta{Name: nodeName}}
					case err != nil:
						return nil, errors.NewInternalError(err)
					default:
						node = nodeObj.(*api.Node)
					}
				}
			}
		case gvk.Group == "" && gvk.Kind == "Node":
			if !utilfeature.DefaultFeatureGate.Enabled(features.ServiceAccountTokenNodeBinding) {

		}
	}
	if pods, err = om.podsLister.Pods(set.Namespace).List(selector); err != nil {
		t.Error(err)
	}
	if testDeletePodFailure {
		// Expect pod deletion failure
		om.SetDeleteStatefulPodError(apierrors.NewInternalError(errors.New("API server failed")), 0)
		expectedNumOfDeleteRequests++
		if _, err = ssc.UpdateStatefulSet(context.TODO(), set, pods); !isOrHasInternalError(err) {

		IneffectiveSelector,
		IneffectivePolicy,
		UnknownUpgradeCompatibility,
		UpdateIncompatibility,
		MultiClusterInconsistentService,
	}
}

// NewInternalError returns a new diag.Message based on InternalError.
func NewInternalError(r *resource.Instance, detail string) diag.Message {
	return diag.NewMessage(
		InternalError,
		r,
		detail,
	)
}

	}
	waiter := newAdmissionWaiter(a)

	e.addWork(waiter)

	// wait for completion or timeout
	select {
	case <-waiter.finished:
	case <-time.After(10 * time.Second):
		return apierrors.NewInternalError(fmt.Errorf("resource quota evaluation timed out"))
	}

	return waiter.result
}

func (e *quotaEvaluator) addWork(a *admissionWaiter) {
	e.workLock.Lock()
	defer e.workLock.Unlock()

		return out, false, err
	}
	// check if obj has pending finalizers
	accessor, err := meta.Accessor(obj)
	if err != nil {
		return nil, false, apierrors.NewInternalError(err)
	}
	pendingFinalizers := len(accessor.GetFinalizers()) != 0
	var ignoreNotFound bool
	var deleteImmediately bool = true
	var lastExisting, out runtime.Object

					},
					Status: batchv1.JobStatus{StartTime: &metav1.Time{Time: justBeforeTheHour()}},
				},
			},
			jobCreateError:      errors.NewInternalError(fmt.Errorf("quota for # of jobs reached")),
			expectedDeletedJobs: []string{"finished-job-started-hour-ago"},
		},
		{
			name: "jobs are not deleted if history limit not reached",