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[])

            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

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

	binary.BigEndian.PutUint32(b, uint32(length))
	if _, err := w.Write(b); err != nil {
		panic(err) // Write() on hash never fails
	}
}

// toBytes performs unholy acts to avoid allocations
func toBytes(s string) []byte {
	// unsafe.StringData is unspecified for the empty string, so we provide a strict interpretation
	if len(s) == 0 {
		return nil
	}
	// Copied from go 1.20.1 os.File.WriteString

    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:

    }

    def "uses efficient serialization for Paths"() {
        expect:
        def serializer = factory.getSerializerFor(Path)
        def encoded = toBytes(Paths.get("some-file"), serializer)
        fromBytes(encoded, serializer) == Paths.get("some-file")
        encoded.length == 10
    }

    def "uses efficient serialization for Long"() {
        expect: