registry.register(Integer, intSerializer)
        def serializer = registry.build(Number)

        expect:
        serialize(123L, serializer) == 123L
        serialize(123, serializer) == 123
        toBytes(123L, serializer).length == toBytes(123L, longSerializer).length + 1
    }

    def "does not write type tag when there is only one matching registered type"() {
        given:

        converter.convert(123 as Short, Long.class, false) == 123L
        converter.convert(123 as Integer, Long.class, false) == 123L
        converter.convert(123 as Long, Long.class, false) == 123L
        converter.convert(123 as Double, Long.class, false) == 123L
        converter.convert(123 as BigInteger, Long.class, false) == 123L
        converter.convert(123 as BigDecimal, Long.class, false) == 123L
    }

        new DefaultTaskFinishedProgressEvent(123L, Stub(DefaultTaskDescriptor), Stub(DefaultTaskSkippedResult))
    }

    private OperationStartEvent startOperationEvent() {
        new OperationStartEvent(123)
    }

    private OperationProgressEvent operationProgressEvent() {
        new OperationProgressEvent(123, null)
    }

    private OperationFinishEvent operationFinishEvent() {

        def event1 = new TestCompleteEvent(123L, TestResult.ResultType.SUCCESS)
        def event2 = new TestCompleteEvent(123L, null)

        when:
        def result1 = serialize(event1)
        def result2 = serialize(event2)

        then:
        result1 instanceof TestCompleteEvent
        result1.endTime == 123L
        result1.resultType == TestResult.ResultType.SUCCESS

        encoded.length == 10
    }

    def "uses efficient serialization for Long"() {
        expect:
        def serializer = factory.getSerializerFor(Long)
        usesEfficientSerialization(123L, serializer) == 123L
    }

    enum Letters {
        A, B, C
    }

    def "uses efficient serialization for Enum"() {
        expect:
        def serializer = factory.getSerializerFor(Letters)

        when:
        def result = twoStageCache.get(key)

        then:
        1 * readCache.get(key) >> {
            r1
        }
        1 * writeCache.get(key) >> {
            r2
        }
        result.moduleVersionListing == ["1.0", "1.1", "1.2", "1.3"] as Set
        result.createTimestamp == 123L
    }

                          [long, "123L"],
                          [Long, "123L"],
                          [short, "123"],
                          [Short, "123"],
                          [int, "123"],
                          [Integer, "123"],
                          [double, "123.456d"],
                          [Double, "123.456d"],
                          [String, '"Mogette"'],

        def snapshot2 = snapshotter.snapshot(["123"] as String[])
        snapshot2 instanceof ArrayValueSnapshot
        snapshot2 == snapshotter.snapshot(["123"] as String[])
        snapshot2 == snapshotter.snapshot(["123"] as CharSequence[])
        snapshot2 == snapshotter.snapshot(["123"] as Object[])
        snapshot2 != snapshotter.snapshot(["123"])
        snapshot2 != snapshotter.snapshot("123")
        snapshot2 != snapshot1
    }

    def "can serialize user input resume event"() {
        given:
        def event = new UserInputResumeEvent(123)

        when:
        def result = serialize(event, serializer)

        then:
        result instanceof UserInputResumeEvent
        result.timestamp == 123l
        result.logLevel == LogLevel.QUIET
    }

                getRequested() >> requested
            }
            getFromVariant() >> 55L
            getFailure() >> null
            getSelected() >> 12L
            getSelectedVariant() >> 123L
            getReason() >> ComponentSelectionReasons.requested()
        }

        when:
        def bytes = new ByteArrayOutputStream()
        def encoder = new OutputStreamBackedEncoder(bytes)