}

var _ sort.Interface = NamespacedNames{}

// NamespacedNames is a list of NamespacedName.
type NamespacedNames []NamespacedName

func (n NamespacedNames) Less(i, j int) bool {
	return strings.Compare(n[i].PrefixString(), n[j].PrefixString()) < 0
}

func (n NamespacedNames) Swap(i, j int) {
	n[i], n[j] = n[j], n[i]
}

func (n NamespacedNames) Len() int {
	return len(n)
}

	for _, svc := range nDestinations(ctx, n, filteredTargets) {
		svc := svc

		namespacedNames := svc.NamespacedNames()
		var toNames []string
		if includeNS {
			toNames = namespacedNames.NamesWithNamespacePrefix()
		} else {
			toNames = namespacedNames.Names()
		}

		ctx.NewSubTestf("to %s", strings.Join(toNames, " ")).Run(func(ctx framework.TestContext) {
			testFn(ctx, svc)

		app := app
		g.Go(app.Restart)
	}
	return g.Wait().ErrorOrNil()
}

func (i Instances) Len() int {
	return len(i)
}

func (i Instances) NamespacedNames() NamespacedNames {
	out := make(NamespacedNames, 0, i.Len())
	for _, ii := range i {
		out = append(out, ii.NamespacedName())
	}

	sort.Stable(out)
	return out

	out := d.Copy()
	for _, o := range others {
		out = append(out, o...)
	}
	sort.Stable(out)
	return out
}

func (d Services) NamespacedNames() NamespacedNames {
	out := make(NamespacedNames, 0, d.Len())
	for _, svc := range d {
		out = append(out, svc.NamespacedName())
	}

	sort.Stable(out)
	return out

	framework.NewTest(t).
		Run(func(t framework.TestContext) {
			allowed := apps.Ns1.A
			denied := apps.Ns2.A

			from := allowed.Append(denied)
			fromMatch := match.AnyServiceName(from.NamespacedNames())
			toMatch := match.Not(fromMatch)
			to := toMatch.GetServiceMatches(apps.Ns1.All)
			fromAndTo := to.Instances().Append(from)

			config.New(t).
				Source(config.File("testdata/authz/mtls.yaml.tmpl")).

	for index, namespacedName := range apps.Ns1.All.NamespacedNames() {
		switch {
		case namespacedName.Name == "client":
			client = apps.Ns1.All[index]
		case namespacedName.Name == "server":
			server = apps.Ns1.All[index]
		case namespacedName.Name == "internal-client":
			internalClient = apps.Ns1.All[index]
		}
	}
	for index, namespacedName := range apps.Ns2.All.NamespacedNames() {
		switch {

	lock sync.Mutex
	// numEndpoints represents the total number of endpoints stored in
	// EndpointSlices.
	numEndpoints int
	// cache stores a EndpointPortCache grouped by NamespacedNames representing
	// Services.
	cache map[types.NamespacedName]*EndpointPortCache
}

// EndpointPortCache tracks values for total numbers of desired endpoints as well

func TestMain(m *testing.M) {
	framework.NewSuite(m).EnvironmentFactory(resource.NilEnvironmentFactory).Run()
}

func TestDeployments(t *testing.T) {
	if diff := cmp.Diff(
		all.Services().NamespacedNames(),
		echo.NamespacedNames{
			{
				Name:      "a",
				Namespace: echo1NS,
			},
			{
				Name:      "a",
				Namespace: echo2NS,
			},
			{
				Name:      "b",
				Namespace: echo1NS,
			},

		return n == i.NamespacedName()
	}
}

// AnyServiceName matches instances if they have the same Service and Namespace as any of the provided instances.
func AnyServiceName(expected echo.NamespacedNames) Matcher {
	return func(instance echo.Instance) bool {
		serviceName := instance.NamespacedName()
		for _, expectedName := range expected {
			if serviceName == expectedName {
				return true
			}
		}

`, map[string]string{"pem": rootPEM})
	cfg.ControlPlaneValues = cfgYaml
}

func createCustomInstances(apps *deployment.SingleNamespaceView) error {
	for index, namespacedName := range apps.EchoNamespace.All.NamespacedNames() {
		switch {
		case namespacedName.Name == "client":
			client = apps.EchoNamespace.All[index]
		case namespacedName.Name == "server":
			server = apps.EchoNamespace.All[index]