"CAFEBABE"                         | ByteArrayBackedHashCode | 4      | 0xBEBAFECA | toBytes(0xCA, 0xFE, 0xBA, 0xBE)
        "abbaabba"                         | ByteArrayBackedHashCode | 4      | 0xBAABBAAB | toBytes([0xAB, 0xBA] * 2)
        "abbaabbaabba"                     | ByteArrayBackedHashCode | 6      | 0xBAABBAAB | toBytes([0xAB, 0xBA] * 3)

        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:
        def registry = new DefaultSerializerRegistry()

        KryoBackedEncoder
    }

    Class<? extends AbstractDecoder> getDecoder() {
        KryoBackedDecoder
    }

    <T> T serialize(T value, Serializer<T> serializer) {
        def bytes = toBytes(value, serializer)
        return fromBytes(bytes, serializer)
    }

    /**
     * Serializes and deserializes the given value, asserting that the generated byte sequence is shorter than it would be when default

    }

    def "multiple writes of the same custom reason"() {
        when:
        def single = toBytes(withReason("hello"), serializer)
        def withDuplicate = toBytes(withReasons("hello", "hello"), serializer)
        def withoutDuplicate = toBytes(withReasons("hello", "other"), serializer)

        then:
        single.length < withDuplicate.length
        withDuplicate.length < 2*single.length

    public <T> T serialize(T value, Serializer<T> serializer) {
        def bytes = toBytes(value, serializer)
        return fromBytes(bytes, serializer)
    }

    public <T> T fromBytes(byte[] bytes, Serializer<T> serializer) {
        return serializer.read(new KryoBackedDecoder(new ByteArrayInputStream(bytes)))
    }

    public <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()

	return
}

// ToTimestamp returns the timestamp value if present.
func (v Value) ToTimestamp() (t time.Time, ok bool) {
	t, ok = v.value.(time.Time)
	return
}

// ToBytes returns the value if byte-slice.
func (v Value) ToBytes() (val []byte, ok bool) {
	val, ok = v.value.([]byte)
	return
}

// ToArray returns the value if it is a slice of values.
func (v Value) ToArray() (val []Value, ok bool) {

    def "serializes an empty args array"() {
        expect:
        def arraySerializer = serializer.forTypes([] as Class[])
        serialize([] as Object[], arraySerializer).length == 0
        toBytes([] as Object[], arraySerializer).length == 0
    }

    def "serializes single args"() {
        expect:
        def arraySerializer = serializer.forTypes([String,] as Class[])

import org.gradle.performance.measure.DataAmount
import org.gradle.performance.measure.Duration

import java.math.RoundingMode

@CompileStatic
class PrettyCalculator {

    static String toBytes(Amount<DataAmount> bytes) {
        return bytes.toUnits(DataAmount.BYTES).value.setScale(3, RoundingMode.HALF_UP).stripTrailingZeros().toString() + " B"
    }

    static String toMillis(Amount<Duration> duration) {

            DefaultModuleIdentifier.newId('group3', 'name3'), constraint('1.0'), factory.of(attr, "val1"), [])

        when:
        byte[] result1 = toBytes(selector1, serializer)
        byte[] result2 = toBytes(selector2, serializer)
        byte[] result3 = toBytes(selector3, serializer)

        then:
        result2.length == result1.length // different attributes
        result3.length < result1.length // already seen

    def "serializes an empty args array"() {
        expect:
        def arraySerializer = serializer.forTypes([] as Class[])
        serialize([] as Object[], arraySerializer).length == 0
        toBytes([] as Object[], arraySerializer).length == 0
    }

    def "serializes multiple args using the serializer registry that can serialize all types"() {
        given: