if _, exist := set[e]; !exist {
			t.Errorf("%s is not in set %v", e, set)
		}
	}
}

func TestUnion(t *testing.T) {
	elements := []string{"a", "b", "c", "d"}
	elements2 := []string{"a", "b", "e"}
	want := New("a", "b", "c", "d", "e")
	for _, sets := range [][]Set[string]{
		{New(elements...), New(elements2...)},
		{New(elements2...), New(elements...)},
	} {
		s1, s2 := sets[0], sets[1]
		if got := s1.Union(s2); !got.Equals(want) {

	set1 := newStatefulSet(3)
	set2 := newStatefulSet(3)
	set2.Name = "foo2"
	set3 := newStatefulSet(3)
	set3.Name = "foo3"
	set3.Spec.Selector.MatchLabels = map[string]string{"foo3": "bar"}
	pod := newStatefulSetPod(set1, 0)
	om.setsIndexer.Add(set1)
	om.setsIndexer.Add(set2)
	om.setsIndexer.Add(set3)

	// Make pod an orphan. Expect matching sets to be queued.
	pod.OwnerReferences = nil

		items2 = append(items2, fmt.Sprint(i))
	}
	b.Run("Set", func(b *testing.B) {
		set1000 := sets.New(items1000...)
		set100 := sets.New(items100...)
		set2 := sets.New(items2...)
		b.Run("New/1", func(b *testing.B) {
			for range b.N {
				_ = sets.New("a")
			}
		})
		b.Run("New/1000", func(b *testing.B) {
			for range b.N {
				_ = sets.New(items1000...)
			}
		})

		}
	}
}

func TestIntersection(t *testing.T) {
	tests := []struct {
		s1       sets.Set[string]
		s2       sets.Set[string]
		expected sets.Set[string]
	}{
		{
			sets.New("1", "2", "3", "4"),
			sets.New("3", "4", "5", "6"),
			sets.New("3", "4"),
		},
		{
			sets.New("1", "2", "3", "4"),
			sets.New("1", "2", "3", "4"),

	// TokenTTL flag sets the time to live for token
	TokenTTL = "token-ttl"

	// TokenUsages flag sets the usages of the token
	TokenUsages = "usages"

	// TokenGroups flag sets the authentication groups of the token
	TokenGroups = "groups"

	// TokenDescription flag sets the description of the token
	TokenDescription = "description"

			&BaseEndpointInfo{endpoint: "10.1.2.4:80", zoneHints: sets.New[string]("zone-b"), ready: true},
			&BaseEndpointInfo{endpoint: "10.1.2.5:80", zoneHints: sets.New[string]("zone-c"), ready: true},
			&BaseEndpointInfo{endpoint: "10.1.2.6:80", zoneHints: sets.New[string]("zone-a"), ready: true},
		},

  private Iterable<List<Object>> buildCartesianProduct(Set<?>... sets) {
    List<Set<Optional<?>>> optionalSets = Lists.newArrayListWithExpectedSize(sets.length);
    for (Set<?> set : sets) {
      Set<Optional<?>> optionalSet =
          Sets.newLinkedHashSet(Iterables.transform(set, NULLABLE_TO_OPTIONAL));
      optionalSets.add(optionalSet);
    }
    Set<List<Optional<?>>> cartesianProduct = Sets.cartesianProduct(optionalSets);

		ConfigKey{Kind: kind.WasmPlugin, Name: "name", Namespace: "namespace"}.HashCode():      sets.New(secondEntry.Key()),
	})

	cache.Clear(sets.Set[ConfigKey]{})

	// no change on empty clear
	assert.Equal(t, cache.store.Len(), 2)
	assert.Equal(t, cache.indexLength(), 5)
	assert.Equal(t, cache.configIndexSnapshot(), map[ConfigHash]sets.Set[uint64]{

				"bar":        {RequestedNames: sets.New("bar")},
				"bar.ns":     {RequestedNames: sets.New("bar.ns")},
				"bar.ns.svc": {RequestedNames: sets.New("bar.ns.svc")},
				"bar.ns.svc.cluster.local": {RequestedNames: sets.New(
					"bar",
					"bar.ns",
					"bar.ns.svc",
					"bar.ns.svc.cluster.local",
				)},
				"foo":        {RequestedNames: sets.New("foo"), Ports: sets.New("80")},

		watchedResources []string
		wantExtensions   sets.String
		wantSecrets      sets.String
	}{
		{
			name:             "simple",
			proxyNamespace:   "default",
			request:          &model.PushRequest{Full: true},
			watchedResources: []string{"extenstions.istio.io/wasmplugin/default.default-plugin"},
			wantExtensions:   sets.String{"extenstions.istio.io/wasmplugin/default.default-plugin": {}},