*      interface Animal {}
 * </pre>
 * <p>
 * On the client-side we will be able to write code such as:
 * <pre>
 *      if (model instanceof Dog) {
 *          ((Dog) model).bark();
 *      } else if (model instanceof Cat) {
 *          ((Cat) model).meow();
 *      } else if (model instance of Bird) {
 *          // will never be true, Bird is not specified as a model contract type
 *      }
 * </pre>
 *
 * @since 8.9
 */

	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 {
	return func(instance echo.Instance) bool {
		serviceName := instance.NamespacedName()
		for _, expectedName := range expected {
			if serviceName == expectedName {

   * for more important information about the Java 8+ transition.
   */
  public static Function<Object, String> toStringFunction() {
    return ToStringFunction.INSTANCE;
  }

  // enum singleton pattern
  private enum ToStringFunction implements Function<Object, String> {
    INSTANCE;

    @Override
    public String apply(Object o) {
      checkNotNull(o); // eager for GWT.
      return o.toString();
    }

    @Override

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

class WriteIdentities {

    private
    val instanceIds = IdentityHashMap<Any, Int>()

    fun getId(instance: Any) = instanceIds[instance]

    fun putInstance(instance: Any): Int {
        val id = instanceIds.size
        instanceIds[instance] = id
        return id
    }
}


class ReadIdentities {

    private
    val instanceIds = HashMap<Int, Any>()

        when:
        withEntryPoint(INVOKE_METHOD, "test") {
            instance.test()
            assert instance.intercepted == "test()"
            instance.intercepted = null
            instance.test()
            instance.test(instance) // also call a different signature
        }

        then:
        instance.intercepted == null
    }

// destination instance. This is for ingress gateway testing when source instance
// destination instances. This can be used when we're not using echo workloads
// as the source of traffic, such as from the ingress gateway. For example:
//
//	RunFromClusters(func(t framework.TestContext, src cluster.Cluster, dst echo.Instances)) {
//	  ingr := ist.IngressFor(src)
//	  ingr.CallWithRetryOrFail(...)

   *       is used to construct the sample instances. In case of tie, the candidate constructors or
   *       factories are tried one after another until one can be used to construct sample
   *       instances.
   *   <li>For the constructor or static factory method used to construct instances, it's checked
   *       that when equal parameters are passed, the result instance should also be equal; and vice
   *       versa.

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

The following types/formats are supported:
  - Instances of ConfigurablePublishArtifact.
  - Instances of PublishArtifact.
  - Instances of AbstractArchiveTask, for example jar.
  - Instances of Provider<RegularFile>.
  - Instances of Provider<Directory>.
  - Instances of Provider<File>.
  - Instances of RegularFile.
  - Instances of Directory.
  - Instances of File.
  - Maps with 'file' key'''))
    }