assert startEvent instanceof TaskStartEvent
            assert finishEvent instanceof TaskFinishEvent
            assert descriptor instanceof TaskOperationDescriptor
        }

        void assertIsTest() {
            assert startEvent instanceof TestStartEvent
            assert finishEvent instanceof TestFinishEvent
            assert descriptor instanceof TestOperationDescriptor
        }

            return false
        }

        1 * connection.dispatch({ it instanceof Build })
        2 * connection.receive() >>> [Stub(BuildStarted), new Failure(new DaemonStoppedException())]
        1 * connection.dispatch({ it instanceof Cancel })
        1 * connection.dispatch({ it instanceof CloseInput })
        1 * connection.dispatch({ it instanceof Finished })
        1 * cancellationToken.cancellationRequested >> true

            if (dependency instanceof Buildable) {
                context.add(dependency);
            } else if (dependency instanceof Task) {
                context.add(dependency);
            } else if (dependency instanceof TaskDependency) {
                context.add(dependency);
            } else if (dependency instanceof ProviderInternal) {

        }
        if (left instanceof ModuleExclude) {
            return tryModuleUnion((ModuleExclude) left, right);
        } else if (right instanceof ModuleExclude) {
            return tryModuleUnion((ModuleExclude) right, left);
        }
        if (left instanceof GroupExclude) {
            return tryGroupUnion((GroupExclude) left, right);
        } else if (right instanceof GroupExclude) {

        if (one.equals(two)) {
            return one;
        }
        if (one instanceof ExcludeEverything) {
            return one;
        }
        if (one instanceof ExcludeNothing) {
            return two;
        }
        if (two instanceof ExcludeEverything) {
            return two;
        }
        if (two instanceof ExcludeNothing) {
            return one;
        }
        return onMiss.apply(one, two);

        def result = serialize(info)

        then:
        result instanceof DefaultTestClassRunInfo
        result.testClassName == "some-test"
    }

    def "serializes CompositeId"() {
        def id = new CompositeIdGenerator.CompositeId(1L, 2L)

        when:
        def result = serialize(id)

        then:
        result instanceof CompositeIdGenerator.CompositeId
        result == id
    }

    }

    private boolean isClassFieldConstructorOrMethod(JApiCompatibility member) {
        return member instanceof JApiClass || member instanceof JApiField || member instanceof JApiConstructor || member instanceof JApiMethod;
    }

    private boolean isInject(JApiCompatibility member) {
        return member instanceof JApiHasAnnotations && isInject((JApiHasAnnotations) member);
    }

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

        1 * connection.dispatch({it instanceof Stop})
        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()
        1 * connection2.dispatch({it instanceof Stop})
        1 * connection2.receive() >> new Success(null)
        1 * connection2.dispatch({it instanceof Finished})
        1 * connection2.stop()
        0 * _
    }

    def "assembles schema for unmanaged type"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeType))
        schema instanceof UnmanagedImplStructSchema
        !(schema instanceof ManagedImplSchema)
        !(schema instanceof CompositeSchema)
        schema instanceof StructSchema
        !schema.annotated
        schema.propertyNames == ['readOnlyString', 'strings'] as SortedSet