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

            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)

        if (!(methodCall.getArguments() instanceof ArgumentListExpression)) {
            return null;
        }

        ArgumentListExpression args = (ArgumentListExpression) methodCall.getArguments();
        if (args.getExpressions().size() == 2 && args.getExpression(0) instanceof ClassExpression && args.getExpression(1) instanceof ClosureExpression) {

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

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

        def result3 = serialize(message3, serializer)
        result3 instanceof Success
        result3.value instanceof BuildActionResult
        !result3.value.wasCancelled()
        result3.value.result == null
        result3.value.failure == null
        result3.value.exception instanceof RuntimeException

        def buildCancelled = BuildActionResult.cancelled(new RuntimeException("broken"))

        // shortcut
        if (to instanceof Class && from instanceof Class) {
            return ((Class<?>) to).isAssignableFrom((Class<?>) from);
        }
        return isAssignable(to, from, false);
    }

    private static boolean isAssignable(Type to, Type from, boolean strict) {
        if (to instanceof WildcardType || from instanceof WildcardType) {
            Type[] toUppers, toLowers;

            projectConfigurationProgressListeners.getSource().statusChanged(event);
        } else if (event instanceof TransformProgressEvent) {
            transformProgressListeners.getSource().statusChanged(event);
        } else if (event instanceof TestOutputEvent) {
            testOutputProgressListeners.getSource().statusChanged(event);

        isolated1 instanceof IsolatedArray
        def copy1 = isolated1.isolate()
        copy1 == [] as String[]
        copy1.class == String[].class
        !copy1.is(original1)

        def original2 = ["123"] as String[]
        def isolated2 = isolatableFactory.isolate(original2)
        isolated2 instanceof IsolatedArray
        def copy2 = isolated2.isolate()

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