}

    def "can use Java serialization for registered type"() {
        given:
        def registry = new DefaultSerializerRegistry()
        registry.useJavaSerialization(Long)
        registry.useJavaSerialization(Integer)
        def serializer = registry.build(Number)

        expect:
        serialize(123L, serializer) == 123L
        serialize(123, serializer) == 123
    }

    /**
     * Use Java serialization for the specified type and all subtypes. Should be avoided, but useful when migrating to using serializers or when dealing with
     * arbitrary user types.
     */
    <T> void useJavaSerialization(Class<T> implementationType);

    /**
     * Returns true when this registry can serialize objects of the given type.
     */
    boolean canSerialize(Class<?> baseType);

    /**

                conditions.evaluate {
                    serializableClasses.forEach { theClass ->
                        try {
                            defaultSerializerRegistry.useJavaSerialization(theClass)
                            defaultSerializerRegistry.register(theClass, serializer)
                            Thread.sleep(1)
                        } finally {
                            latch.countDown()

            return readArray(decoder);
        } else {
            String stateClassName = decoder.readString();
            Class<?> stateClass = fromClassName(stateClassName);
            useJavaSerialization(stateClass);
            return build(stateClass).read(decoder);
        }
    }

    private void writeState(Encoder encoder, Object state) throws Exception {
        if (state == null) {

        serializerMap.put(implementationType, serializerProvider);
    }

    @Override
    public <T> void useJavaSerialization(Class<T> implementationType) {
        javaSerialization.put(implementationType, Boolean.TRUE);
    }

    @Override
    public boolean canSerialize(Class<?> baseType) {

        registry.register(OutputMessage.class, new OutputMessageSerializer(registry.build(OutputEvent.class)));

        // Default for everything else
        registry.useJavaSerialization(Message.class);

        return registry.build(Message.class);
    }

    private static class SuccessSerializer implements Serializer<Success> {