Resolution:         "STATIC",
			},
		})
		proxy := s.SetupProxy(baseProxy())

		endpoints := xdstest.ExtractLoadAssignments(s.Endpoints(proxy))
		if !slices.EqualUnordered(endpoints["outbound|80||app.com"], []string{"1.1.1.1:80"}) {
			t.Fatalf("expected 1.1.1.1, got %v", endpoints["outbound|80||app.com"])
		}

		assertListEqual(t, xdstest.ExtractListenerNames(s.Listeners(proxy)), []string{

// comparison stops at the first unequal pair.
// Floating point NaNs are not considered equal.
func Equal[E comparable](s1, s2 []E) bool {
	return slices.Equal(s1, s2)
}

// EqualUnordered reports whether two slices are equal, ignoring order
func EqualUnordered[E comparable](s1, s2 []E) bool {
	if len(s1) != len(s2) {
		return false
	}
	first := make(map[E]struct{}, len(s1))
	for _, c := range s1 {
		first[c] = struct{}{}
	}

			for c, want := range w.expectations {
				got := eps[c]
				if !slices.EqualUnordered(got, want) {
					err := fmt.Errorf("cluster %s, expected %v, but got %v", c, want, got)
					fmt.Println(err)
					return err
				}
			}
			for c, got := range eps {
				want := w.expectations[c]
				if !slices.EqualUnordered(got, want) {
					err := fmt.Errorf("cluster %s, expected %v, but got %v", c, want, got)

	}
	var notEqual []string
	for i := 0; i < size; i++ {
		notEqual = append(notEqual, strconv.Itoa(i))
	}
	notEqual[size-1] = "z"

	for n := 0; n < b.N; n++ {
		EqualUnordered(l, equal)
		EqualUnordered(l, notEqual)
	}
}

func TestFilterDuplicates(t *testing.T) {
	tests := []struct {
		name string
		in   []string
		out  []string
	}{
		{
			name: "empty",

		wr.NonceAcked = request.ResponseNonce
		wr.ResourceNames = currentResources
		alwaysRespond = wr.AlwaysRespond
		wr.AlwaysRespond = false
		return wr
	})

	subChanged := !slices.EqualUnordered(previousResources, currentResources)
	// Spontaneous DeltaDiscoveryRequests from the client.
	// This can be done to dynamically add or remove elements from the tracked resource_names set.