bean instanceof ModelObject
        bean.modelIdentityDisplayName == null
        !bean.hasUsefulDisplayName()

        bean instanceof OwnerAware

        !(bean instanceof DynamicObjectAware)
        !(bean instanceof ExtensionAware)
        !(bean instanceof HasConvention)
        !(bean instanceof IConventionAware)
        !(bean instanceof GroovyObject)
    }

        }
        if (o2 instanceof OrdinalNode || o2 instanceof ResolveMutationsNode) {
            return 1;
        }

        if (o1 instanceof CreationOrderedNode) {
            if (o2 instanceof CreationOrderedNode) {
                return ((CreationOrderedNode) o1).getOrder() - ((CreationOrderedNode) o2).getOrder();
            }
            return -1;
        }
        if (o2 instanceof CreationOrderedNode) {

            def expectedValue = getter(expected)
            if (checker instanceof Closure) {
                if (expectedValue instanceof Collection) {
                    assert actualValue instanceof Collection
                    checkCollection(actualValue, expectedValue, checker)
                } else if (expectedValue instanceof Map) {
                    assert actualValue instanceof Map
                    checkMap(actualValue, expectedValue, checker)

            }

            return call.getArguments() instanceof ArgumentListExpression;
        }

        private boolean isTaskIdentifier(Expression expression) {
            return expression instanceof ConstantExpression || expression instanceof GStringExpression;
        }

        private boolean isDynamicVar(Expression expression) {
            if (!(expression instanceof VariableExpression)) {
                return false;

        expect:
        def step = PatternStepFactory.getStep("**", true);
        step instanceof AnyWildcardPatternStep
        step.matches("anything")
        step.matches("")
    }

    def "creates step for * wildcard"() {
        expect:
        def step = PatternStepFactory.getStep("*", true);
        step instanceof AnyWildcardPatternStep
        step.matches("anything")
        step.matches("")
    }

        expect:
        def schema = store.getSchema(ModelTypes.set(ModelType.of(String)))
        schema instanceof ScalarCollectionSchema
        schema instanceof ManagedImplSchema
        !(schema instanceof CompositeSchema)
        !(schema instanceof StructSchema)
        schema.elementType == ModelType.of(String)
        schema.elementTypeSchema == store.getSchema(ModelType.of(String))
    }

    final DirectInstantiator instantiator = DirectInstantiator.INSTANCE

    def "creates instance with constructor parameters"() {
        CharSequence param = Mock()

        expect:
        def result = instantiator.newInstance(SomeType, param)
        result instanceof SomeType
        result.result == param
    }

    def "creates instance with subtypes of constructor parameters"() {
        expect:

        if (o == null) {
            return null;
        } else if (o instanceof Byte) {
            return (Byte) o;
        } else if (o instanceof Number) {
            return ((Number) o).byteValue();
        } else if (o instanceof String) {
            return toByte((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

        if (o == null) {
            return null;
        } else if (o instanceof Integer) {
            return (Integer) o;
        } else if (o instanceof Number) {
            return ((Number) o).intValue();
        } else if (o instanceof String) {
            return toInteger((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

  - A String or CharSequence URI, for example 'file:/usr/include'.
  - A File instance.
  - A Path instance.
  - A Directory instance.
  - A RegularFile instance.
  - A URI or URL instance.
  - A TextResource instance.""")
    }

    def parse(def value) {
        return FileOrUriNotationConverter.parser().parseNotation(value)
    }