t.Helper()

	vhosts := sets.New[string]()
	domains := sets.New[string]()
	for _, vhost := range l.VirtualHosts {
		if vhosts.InsertContains(vhost.Name) {
			t.Errorf("duplicate virtual host found %s", vhost.Name)
		}
		for _, domain := range vhost.Domains {
			if domains.InsertContains(domain) {
				t.Errorf("duplicate virtual host domain found %s", domain)
			}
		}
	}
}

			}
		})
	}
}

func TestInsertContains(t *testing.T) {
	s := New[string]()
	assert.Equal(t, s.InsertContains("k1"), false)
	assert.Equal(t, s.InsertContains("k1"), true)
	assert.Equal(t, s.InsertContains("k2"), false)
	assert.Equal(t, s.InsertContains("k2"), true)
}

func BenchmarkSet(b *testing.B) {
	containsTest := New[string]()
	for i := 0; i < 1000; i++ {

	res := s.UnsortedList()
	slices.Sort(res)
	return res
}

// InsertContains inserts the item into the set and returns if it was already present.
// Example:
//
//		if !set.InsertContains(item) {
//			fmt.Println("Added item for the first time", item)
//	  }
func (s Set[T]) InsertContains(item T) bool {
	if s.Contains(item) {
		return true
	}
	s[item] = struct{}{}
	return false

	}
	return dedupTrustDomains(tds)
}

func dedupTrustDomains(tds []string) []string {
	known := sets.New[string]()
	deduped := make([]string, 0, len(tds))

	for _, td := range tds {
		if td != "" && !known.InsertContains(td) {
			deduped = append(deduped, td)
		}
	}
	return deduped

	for _, curConfigs := range storeConfigs {
		configs = append(configs, curConfigs...)
	}
	configs = slices.FilterInPlace[config.Config](configs, func(cfg config.Config) bool {
		return !configMap.InsertContains(cfg.NamespacedName())
	})

	return configs
}

func (cr *store) Delete(typ config.GroupVersionKind, name, namespace string, resourceVersion *string) error {
	if cr.writer == nil {

				} else {
					validateFn = "validation." + validateFn
				}
			}
			m.Resources[i].Validate = validateFn
		}
		if r.Identifier == "" {
			r.Identifier = r.Kind
		}
		if seen.InsertContains(r.Identifier) {
			return fmt.Errorf("identifier %q already registered, set a unique identifier", r.Identifier)
		}
	}

	return nil
}

// Parse and return a yaml representation of Metadata

		}
	}
	return nil
}

func (j *join[T]) List() []T {
	res := []T{}
	found := sets.New[Key[T]]()
	for _, c := range j.collections {
		for _, i := range c.List() {
			key := GetKey(i)
			if !found.InsertContains(key) {
				// Only keep it if it is the first time we saw it, as our merging mechanism is to keep the first one
				res = append(res, i)
			}
		}
	}
	return res
}

		{"FuzzJwtUtil", FuzzJwtUtil},
		{"FuzzFindRootCertFromCertificateChainBytes", FuzzFindRootCertFromCertificateChainBytes},
		{"FuzzCRDRoundtrip", FuzzCRDRoundtrip},
	}
	for _, tt := range cases {
		if testedFuzzers.InsertContains(tt.name) {
			t.Fatalf("dupliate fuzzer test %v", tt.name)
		}
		t.Run(tt.name, func(t *testing.T) {
			runRegressionTest(t, tt.name, tt.fuzzer)
		})
	}
	t.Run("completeness", func(t *testing.T) {

// debugging
func (c *suiteContext) allocateContextID(prefix string) string {
	c.contextMu.Lock()
	defer c.contextMu.Unlock()

	candidate := prefix
	discriminator := 0
	for {
		if !c.contextNames.InsertContains(candidate) {
			return candidate
		}

		candidate = fmt.Sprintf("%s-%d", prefix, discriminator)
		discriminator++
	}
}

	certMap := sets.New[string]()

	tb.mutex.Lock()
	defer tb.mutex.Unlock()

	for _, configSource := range tb.sourceConfig {
		for _, cert := range configSource.Certs {
			if !certMap.InsertContains(cert) {
				mergeCerts = append(mergeCerts, cert)
			}
		}
	}
	tb.mergedCerts = mergeCerts
	sort.Strings(tb.mergedCerts)
}