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

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

    }

    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:

Inversement, dans la plupart des cas vous pourrez juste envoyer l'objet récupéré de la base de données **directement au client**

Avec **FastAPI** vous aurez toutes les fonctionnalités de **Pydantic**  (comme FastAPI est basé sur Pydantic pour toutes les manipulations de données):

* **Pas de prise de tête**:
    * Pas de nouveau langage de définition de schéma à apprendre.

//go:linkname write

// used by cgo
//go:linkname _cgo_panic_internal
//go:linkname cgoAlwaysFalse
//go:linkname cgoUse
//go:linkname cgoCheckPointer
//go:linkname cgoCheckResult
//go:linkname cgoNoCallback
//go:linkname gobytes
//go:linkname gostringn

// used in plugin
//go:linkname doInit

// used in math/bits
//go:linkname overflowError
//go:linkname divideError

// used in tests
//go:linkname extraMInUse

        assertEquals(expectedOutput, Base64Factory.createEncoder().encodeToString(input.asciiToByteArray()))
    }

    private fun String.asciiToByteArray() = ByteArray(length) {
        get(it).code.toByte()
    }

        when (readByte()) {
            1.toByte() -> ValueSupplier.ExecutionTimeValue.missing<Any>()
            2.toByte() -> ValueSupplier.ExecutionTimeValue.ofNullable(read()) // nullable because serialization may replace value with null, e.g. when using provider of Task
            3.toByte() -> {
                val value = read()

# Guide de l'utilisateur avancé

## Caractéristiques supplémentaires

Le [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank} devrait suffire à vous faire découvrir toutes les fonctionnalités principales de **FastAPI**.

Dans les sections suivantes, vous verrez des options, configurations et fonctionnalités supplémentaires.

!!! note "Remarque"
    Les sections de ce chapitre ne sont **pas nécessairement "avancées"**.

	var adapters []string
	for adapterName, value := range bytesSentPerSecondData {
		adapters = append(adapters, adapterName)
		newStat := n.adapterStats[adapterName]
		newStat.Name = adapterName
		newStat.TxBytes = newStat.TxBytes + value
		n.adapterStats[adapterName] = newStat
	}

	return adapters
}

func (n *networkCounter) mergePacketsReceivedDiscardedData(packetsReceivedDiscardedData map[string]uint64) []string {