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

        }
        if (value instanceof String) {
            return visitor.stringValue((String) value);
        }
        if (value instanceof Boolean) {
            return visitor.booleanValue((Boolean) value);
        }
        if (value instanceof List) {
            return processList((List<?>) value, visitor);
        }
        if (value instanceof Enum) {
            return visitor.enumValue((Enum<?>) value);

        if (snapshot == NullValueSnapshot.INSTANCE) {
            encoder.writeSmallInt(NULL_SNAPSHOT);
        } else if (snapshot instanceof StringValueSnapshot) {
            StringValueSnapshot stringSnapshot = (StringValueSnapshot) snapshot;
            encoder.writeSmallInt(STRING_SNAPSHOT);
            encoder.writeString(stringSnapshot.getValue());
        } else if (snapshot instanceof ListValueSnapshot) {

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

        expect:
        def compiler = factory.create(JavaCompileSpec.class)
        compiler instanceof ModuleApplicationNameWritingCompiler
        compiler.delegate instanceof AnnotationProcessorDiscoveringCompiler
        compiler.delegate.delegate instanceof NormalizingJavaCompiler
        compiler.delegate.delegate.delegate instanceof JdkJavaCompiler
    }

            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