test.TestDelete(validValidatingAdmissionPolicy())
}

func TestWatch(t *testing.T) {
	storage, server := newInsecureStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validValidatingAdmissionPolicy(),
		[]labels.Set{},
		[]labels.Set{
			{"hoo": "bar"},
		},

	test := genericregistrytest.New(t, storage.Store)
	test.TestList(validNewClaimTemplate("foo"))
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNewClaimTemplate("foo"),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{

	test := genericregistrytest.New(t, storage.Store)
	test.TestList(validNewConfigMap())
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNewConfigMap(),
		// matching labels
		[]labels.Set{
			{"label-1": "value-1"},
			{"label-2": "value-2"},

	test.TestList(validNewResourceSlice("foo"))
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validNewResourceSlice("foo"),
		// matching labels
		[]labels.Set{},
		// not matching labels

	test := genericregistrytest.New(t, storage.Store)
	test.TestList(validNewCronJob())
}

func TestWatch(t *testing.T) {
	storage, _, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNewCronJob(),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{

	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestList(validNewCSINode("foo"))
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validNewCSINode("foo"),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{

	test.TestList(validNewStorageClass("foo"))
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validNewStorageClass("foo"),
		// matching labels
		[]labels.Set{},
		// not matching labels

	test.TestDelete(validValidatingWebhookConfiguration())
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validValidatingWebhookConfiguration(),
		[]labels.Set{},
		[]labels.Set{
			{"hoo": "bar"},
		},

	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestList(validNewCSIDriver("foo"))
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store).ClusterScope()
	test.TestWatch(
		validNewCSIDriver("foo"),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{

	test := genericregistrytest.New(t, storage.Store)
	test.TestList(validNetworkPolicy())
}

func TestWatch(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestWatch(
		validNetworkPolicy(),
		// matching labels
		[]labels.Set{},
		// not matching labels
		[]labels.Set{