if !slices.Contains(proxy.IPAddresses, proxyIP) {
		return nil
	}
	instances := index.GetByIP(proxyIP) // list is ordered by namespace/name
	if len(instances) == 0 {
		return nil
	}
	if len(instances) == 1 { // dominant use case
		// NOTE: for the sake of backwards compatibility, we don't enforce
		//       instance.Namespace == proxy.ConfigNamespace
		return instances[0]
	}

	// try to find workload instance with the same name as proxy

}

func assignRefs(refs []*echo.Instance, instances echo.Instances) error {
	if len(refs) != len(instances) {
		return fmt.Errorf("cannot set %d references, only %d instances were built", len(refs), len(instances))
	}
	for i, ref := range refs {
		if ref != nil {
			*ref = instances[i]
		}
	}
	return nil
}

func (b *builder) BuildOrFail(t test.Failer) echo.Instances {
	t.Helper()
	out, err := b.Build()

	store.addInstances(cpKey, instances)

	// 1. test getByIP
	gotInstances := store.getByIP("1.1.1.1")
	if !reflect.DeepEqual(instances, gotInstances) {
		t.Errorf("got unexpected instances : %v", gotInstances)
	}

	// 2. test getAll
	gotInstances = store.getAll()
	if !reflect.DeepEqual(instances, gotInstances) {
		t.Errorf("got unexpected instances : %v", gotInstances)
	}

	// 3. test getByKey

				doTest(ctx, c, dstInstances)
			})
		}
	})
}

func (t *T) isMultipleNamespaces() bool {
	namespaces := map[string]struct{}{}
	for _, instances := range []echo.Instances{t.sources, t.destinations} {
		for _, i := range instances {
			namespaces[i.Config().Namespace.Name()] = struct{}{}
			if len(namespaces) > 1 {
				return true
			}
		}
	}
	return false
}

		return !m(i)
	}
}

// ServiceName matches instances with the given namespace and service name.
func ServiceName(n echo.NamespacedName) Matcher {
	return func(i echo.Instance) bool {
		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 {

func FindAllInIndex(index Index, predicate func(*model.WorkloadInstance) bool) []*model.WorkloadInstance {
	var instances []*model.WorkloadInstance
	index.ForEach(func(instance *model.WorkloadInstance) {
		if predicate(instance) {
			instances = append(instances, instance)
		}
	})
	return instances

	D echo.Instances
	// IPv6 only echo app to be used by tests if running in dual-stack mode
	E echo.Instances
	// Standard echo app with TPROXY interception mode to be used by tests
	Tproxy echo.Instances
	// Headless echo app to be used by tests
	Headless echo.Instances
	// StatefulSet echo app to be used by tests
	StatefulSet echo.Instances
	// ProxylessGRPC echo app to be used by tests
	ProxylessGRPC echo.Instances

        }
      };
    } else {
      return super.createAsList();
    }
  }

  @Override
  public int size() {
    long distance = domain.distance(first(), last());
    return (distance >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) distance + 1;
  }

  @Override
  public boolean contains(@CheckForNull Object object) {
    if (object == null) {
      return false;
    }
    try {

	defer i.mu.RUnlock()

	keys := i.ipToKeys[ip]
	if len(keys) == 0 {
		return nil
	}
	instances := make([]*model.WorkloadInstance, 0, len(keys))
	for _, key := range sets.SortedList(keys) {
		if instance, exists := i.keyToInstance[key]; exists {
			instances = append(instances, instance)
		}
	}
	return instances
}

// Empty implements Index.
func (i *index) Empty() bool {
	i.mu.RLock()

	Call(options CallOptions) (CallResult, error)
	CallOrFail(t test.Failer, options CallOptions) CallResult
}

type Callers []Caller

// Instances returns an Instances if all callers are Instance, otherwise returns nil.
func (c Callers) Instances() Instances {
	var out Instances
	for _, caller := range c {
		c, ok := caller.(Instance)
		if !ok {
			return nil
		}
		out = append(out, c)
	}
	return out