!n1.is(factory.named(Named, "a"))
        !n2.is(factory.named(Named, "b"))

        n1 instanceof Managed
    }

    def "can unpack and recreate instance of subtype of Named"() {
        expect:
        def n1 = factory.named(CustomNamed, "a")
        n1 instanceof Managed
        n1.publicType() == CustomNamed
        n1.isImmutable()
        def state = n1.unpackState()

    }
    // same value. below comes before above
    return Booleans.compare(this instanceof AboveValue, that instanceof AboveValue);
  }

  C endpoint() {
    return endpoint;
  }

  @SuppressWarnings("unchecked") // catching CCE
  @Override
  public boolean equals(@CheckForNull Object obj) {
    if (obj instanceof Cut) {
      // It might not really be a Cut<C>, but we'll catch a CCE if it's not

        return "Classpath{entries=" + entries + "}";
    }

    private boolean isDependency(ClasspathEntry entry) {
        return entry instanceof ProjectDependency || entry instanceof AbstractLibrary;
    }

    private boolean isJreContainer(ClasspathEntry entry) {
        return entry instanceof Container && ((Container) entry).getPath().startsWith("org.eclipse.jdt.launching.JRE_CONTAINER");
    }

    }
  }

  /** Returns a fresh {@link InternerBuilder} instance. */
  public static InternerBuilder newBuilder() {
    return new InternerBuilder();
  }

  /**
   * Returns a new thread-safe interner which retains a strong reference to each instance it has
   * interned, thus preventing these instances from being garbage-collected. If this retention is

		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,

	}
}

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

    }

    // Also called from generated code
    public static <T> T attachOwner(T instance, ModelObject owner, String propertyName) {
        if (instance instanceof OwnerAware) {
            ((OwnerAware) instance).attachOwner(owner, displayNameFor(owner, propertyName));
        }
        return instance;
    }

    // Called from generated code
    public void applyRole(Object value, ModelObject owner) {

    }
  }

  /** Returns a fresh {@link InternerBuilder} instance. */
  public static InternerBuilder newBuilder() {
    return new InternerBuilder();
  }

  /**
   * Returns a new thread-safe interner which retains a strong reference to each instance it has
   * interned, thus preventing these instances from being garbage-collected. If this retention is

    }

    @Override
    public int indexOf(@CheckForNull Object target) {
      return target instanceof Double ? parent.indexOf((Double) target) : -1;
    }

    @Override
    public int lastIndexOf(@CheckForNull Object target) {
      return target instanceof Double ? parent.lastIndexOf((Double) target) : -1;
    }

    @Override

    }

    @Override
    public int indexOf(@CheckForNull Object target) {
      return target instanceof Integer ? parent.indexOf((Integer) target) : -1;
    }

    @Override
    public int lastIndexOf(@CheckForNull Object target) {
      return target instanceof Integer ? parent.lastIndexOf((Integer) target) : -1;
    }

    @Override