sort.Stable(out)
	return out
}

// Copy this Instances array.
func (i Instances) Copy() Instances {
	return append(Instances{}, i...)
}

// Append returns a new Instances array with the given values appended.
func (i Instances) Append(instances Instances) Instances {
	return append(i.Copy(), instances...)
}

// Restart each Instance
func (i Instances) Restart() error {
	g := multierror.Group{}

	return newOption("nodeID", value)
}

func NodeType(value string) Instance {
	ntype := strings.Split(value, "~")[0]
	return newOption("nodeType", ntype)
}

func XdsType(value string) Instance {
	return newOption("xds_type", value)
}

func Region(value string) Instance {
	return newOptionOrSkipIfZero("region", value)
}

func Zone(value string) Instance {

dwq <******@****.***> 1656083735 +0800

								{
									Instance: &resourceapi.NamedResourcesInstance{Name: "X"},
								},
								{
									Instance: &resourceapi.NamedResourcesInstance{Name: "Y"},
								},
							},
						},
					},
					"driver-b": {
						NamedResources: namedresourcesmodel.Model{
							Instances: []namedresourcesmodel.InstanceAllocation{
								{

		Selector: `attributes.bool["usable"]`,
	}

	instance1 := "instance-1"
	oneInstance := Model{
		Instances: []InstanceAllocation{{
			Instance: &resourceapi.NamedResourcesInstance{
				Name: instance1,
			},
		}},
	}

	instance2 := "instance-2"
	twoInstances := Model{
		Instances: []InstanceAllocation{
			{
				Instance: &resourceapi.NamedResourcesInstance{
					Name: instance1,

			if instance.Allocated {
				continue
			}
			if c.filter != nil {
				okay, err := c.filter.Evaluate(ctx, instance.Instance.Attributes)
				if err != nil {
					return nil, fmt.Errorf("evaluate filter CEL expression: %w", err)
				}
				if !okay {
					continue
				}
			}
			okay, err := request.Evaluate(ctx, instance.Instance.Attributes)
			if err != nil {

			continue
		}
		if _, f := s.instances[ikey]; !f {
			s.instances[ikey] = map[configKeyWithParent][]*model.ServiceInstance{}
		}
		s.instancesByHostAndPort.Insert(hostPort)
		s.instances[ikey][key] = append(s.instances[ikey][key], instance)
		if instance.Endpoint.Address != "" {
			s.ip2instance[instance.Endpoint.Address] = append(s.ip2instance[instance.Endpoint.Address], instance)
		}
	}
}

	}
}

func sortServiceTargets(instances []model.ServiceTarget) {
	sort.Slice(instances, func(i, j int) bool {
		if instances[i].Service.Hostname == instances[j].Service.Hostname {
			if instances[i].Port.TargetPort == instances[j].Port.TargetPort {
				return instances[i].Port.TargetPort < instances[j].Port.TargetPort
			}
		}
		return instances[i].Service.Hostname < instances[j].Service.Hostname
	})
}

			}
		}

		return outServices.Instances()
	}
}

func notRegularPods() Filter {
	return func(instances echo.Instances) echo.Instances {
		return match.NotRegularPod.GetMatches(instances)
	}
}

// FilterMatch returns a filter that simply applies the given matcher.
func FilterMatch(matcher match.Matcher) Filter {
	return func(instances echo.Instances) echo.Instances {
		return matcher.GetMatches(instances)

	"istio.io/istio/pkg/test/framework/components/echo"
)

// Matcher is used to filter matching instances
type Matcher func(echo.Instance) bool

// GetMatches returns the subset of echo.Instances that match this Matcher.
func (m Matcher) GetMatches(i echo.Instances) echo.Instances {
	out := make(echo.Instances, 0)
	for _, i := range i {
		if m(i) {
			out = append(out, i)
		}
	}
	return out
}