if resources == nil {
		return
	}

	for i := range resources.Instances {
		m.Instances = append(m.Instances, InstanceAllocation{Instance: &resources.Instances[i]})
	}
}

// AddAllocation may get called after AddResources to mark some resource
// instances as allocated. The result parameter may be nil.
func AddAllocation(m *Model, result *resourceapi.NamedResourcesAllocationResult) {
	if result == nil {
		return
	}

								},
							},
						},
					},
				},
			}},
		},

		"two-instances": {
			slices: sliceList{
				&resourceapi.ResourceSlice{
					NodeName:   "node",
					DriverName: "driver",
					ResourceModel: resourceapi.ResourceModel{
						NamedResources: &resourceapi.NamedResourcesResources{
							Instances: []resourceapi.NamedResourcesInstance{{Name: "one"}, {Name: "two"}},
						},
					},
				},

			}
		}

		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
}

	}
}

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
	})
}

}

// New creates a *T using the given applications as sources and destinations for each subtest.
func New(ctx framework.TestContext, instances echo.Instances) *T {
	s, d := make(echo.Instances, len(instances)), make(echo.Instances, len(instances))
	copy(s, instances)
	copy(d, instances)
	t := &T{
		rootCtx:      ctx,
		cfg:          config.New(ctx),
		sources:      s,
		destinations: d,
	}

			filter: func(instances echo.Instances) echo.Instances {
				return echotest.ReachableDestinations(naked1, instances)
			},
			expect: echo.Instances{
				// only same network/cluster, no VMs
				a1, a1Ns2, b1, c1, headless1, naked1, external1,
			},
		},
		"ReachableDestinations from vm": {
			filter: func(instances echo.Instances) echo.Instances {

    }

    def "suggests model paths with Levenshtein distance lower than 4"() {
        when:
        availablePaths = ["task.afoobar", "tasks.boofar", "tasks.foobar", "tasks.f", "fooba"]

        then:
        suggestionsFor("tasks.fooba") == ["tasks.foobar", "task.afoobar", "tasks.boofar"]
    }

    def "suggests model paths with Levenshtein distance lower than half it's length for strings shorter than 6 characters"() {

     *
     * <p>Use for any non-model types for which services or user provided constructor values need to injected. This is simply a convenience for {@link #injectScheme()}.
     *
     * @param services The services to make available to instances.
     */
    InstanceGenerator inject(ServiceLookup services);

// ResolveGatewayInstances attempts to resolve all instances that a gateway will be exposed on.
// Note: this function considers *all* instances of the service; its possible those instances will not actually be properly functioning
// gateways, so this is not 100% accurate, but sufficient to expose intent to users.
// The actual configuration generation is done on a per-workload basis and will get the exact set of matched instances for that workload.
// Four sets are exposed: