if (o == null || getClass() != o.getClass()) {
            return false;
        }

        ModelPath modelPath = (ModelPath) o;

        return components.length == modelPath.components.length && path.equals(modelPath.path);
    }

    @Override
    public int hashCode() {
        return path.hashCode();
    }

    @Override
    public Iterator<String> iterator() {

        then:
        e = thrown(ModelPath.InvalidNameException)
        e.message =~ "contains illegal"

        when:
        ModelPath.validateName("Z9z")
        ModelPath.validateName("abc")
        ModelPath.validateName("aBC")
        ModelPath.validateName("a10")
        ModelPath.validateName("_")
        ModelPath.validateName("_a")
        ModelPath.validateName("__")
        ModelPath.validateName("a_Z")

        then:

    @Nullable
    private final ModelPath path;
    private final ModelType<T> type;
    @Nullable
    private final ModelPath scope;
    private final ModelNode.State state;
    @Nullable
    private final String description;

    private int hashCode;

    private ModelReference(@Nullable ModelPath path, ModelType<T> type, @Nullable ModelPath scope, @Nullable ModelNode.State state, @Nullable String description) {

    def "realizes a nodes link of a given type when task dependencies visited"() {
        given:
        ModelRegistryHelper registry = new ModelRegistryHelper()
        ModelPath path = ModelPath.path("tasks")
        registry.registerInstance("tasks", "foo tasks")
            .mutate {
            it.path "tasks" node {
                it.addLinkInstance(taskPath, Mock(realizableType))
            }

        this.modelPath = modelPath;
        this.modelRegistry = modelRegistry;
    }

    private NonTransformedModelDslBacking getChildPath(String name) {
        ModelPath path = modelPath == null ? ModelPath.path(name) : modelPath.child(name);
        return new NonTransformedModelDslBacking(executingDsl, path, modelRegistry);
    }

    private void registerConfigurationAction(final Closure<?> action) {

            }
        }
    }

    @Override
    public List<ModelPath> transform(final ModelPath unavailable) {
        Iterable<Suggestion> suggestions = Iterables.transform(availablePaths, new Function<ModelPath, Suggestion>() {
            @Override
            public Suggestion apply(ModelPath available) {

     * Invoked by transformed DSL configuration rules
     */
    public void configure(String modelPathString, Closure<?> closure) {
        ModelPath modelPath = ModelPath.path(modelPathString);
        DeferredModelAction modelAction = ruleFactory.toAction(Object.class, closure);
        registerAction(modelPath, ModelType.UNTYPED, ModelActionRole.Mutate, modelAction);
    }

    /**
     * Invoked by transformed DSL creation rules
     */

        ModelPath.path("a.b").isDescendant(ModelPath.path("a.b.c"))
        ModelPath.path("a.b").isDescendant(ModelPath.path("a.b.c.d.e"))
        !ModelPath.path("a.b").isDescendant(ModelPath.path("a.a"))
        !ModelPath.path("a.b").isDescendant(ModelPath.path("a.a.b"))
        !ModelPath.path("a.b").isDescendant(ModelPath.path("a.b"))
        !ModelPath.path("a.b").isDescendant(ModelPath.path("a"))

    @Override
    public <T> T realize(String path, ModelType<T> type) {
        return realize(ModelPath.path(path), type);
    }

    @Override
    public <T> T realize(ModelPath path, ModelType<T> type) {
        return toType(type, require(path), "get(ModelPath, ModelType)");
    }

    public ModelNode atState(ModelPath path, ModelNode.State state) {
        return atStateOrMaybeLater(path, state, false);
    }

    }

    @Override
    protected <R, S> ExtractedModelRule buildRule(ModelPath modelPath, MethodRuleDefinition<R, S> ruleDefinition) {
        ModelType<S> modelType = ruleDefinition.getSubjectReference().getType();
        final ModelSchema<S> modelSchema = getModelSchema(modelType, ruleDefinition);
        return new ExtractedManagedCreationRule<R, S>(modelPath, ruleDefinition, modelSchema);
    }