}

    @Test
    @DisplayName("encode without andx succeeds and signs when digest present")
    void testEncodeNoAndxWithSigning() throws Exception {
        DummyAndXBlock block = new DummyAndXBlock();
        TestSigningDigest digest = new TestSigningDigest();
        block.digest = digest;

        byte[] buf = new byte[256];
        int len = block.encode(buf, 0);

        assertTrue(len > 0);

        this.fileName = new String(nameBytes, StandardCharsets.UTF_16LE);
        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        dst[dstIndex] = (byte) (this.replaceIfExists ? 1 : 0);
        dstIndex += 8; // 7 Reserved

     */
    @Override
    public int size() {
        return 40;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeTime(this.createTime, dst, dstIndex);
        dstIndex += 8;

Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.

Ensuite, en arrière-plan, il mettra ces données JSON-compatible (par exemple un `dict`) à l'intérieur d'un `JSONResponse` qui sera utilisé pour envoyer la réponse au client.

* the cloud provider
* the cloud service

* the development
* the development stages

* the dict
* the dictionary
* the enumeration
* the enum
* the enum member

* the encoder
* the decoder
* to encode
* to decode

* the exception
* to raise

* the expression
* the statement

* the frontend
* the backend

* the GitHub discussion
* the GitHub issue

	set                     bool
}

// MarshalXML if non-current days not set to non zero value
func (n NoncurrentVersionExpiration) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if n.IsNull() {
		return nil
	}
	type noncurrentVersionExpirationWrapper NoncurrentVersionExpiration
	return e.EncodeElement(noncurrentVersionExpirationWrapper(n), start)
}

	enc := jsoniter.ConfigCompatibleWithStandardLibrary.NewEncoder(buf)

	for i := range items {
		if err = enc.Encode(items[i]); err != nil {
			return err
		}
	}

	path := filepath.Join(store.directory, key.String())
	if key.Compress {
		err = os.WriteFile(path, s2.Encode(nil, buf.Bytes()), os.FileMode(0o770))
	} else {
		err = os.WriteFile(path, buf.Bytes(), os.FileMode(0o770))
	}

	buf.Reset()

pkg image/png, const NoCompression = -1
pkg image/png, const NoCompression CompressionLevel
pkg image/png, method (*Encoder) Encode(io.Writer, image.Image) error
pkg image/png, type CompressionLevel int
pkg image/png, type Encoder struct
pkg image/png, type Encoder struct, CompressionLevel CompressionLevel

# CL 101750048 math: implement Nextafter32, Robert Griesemer <******@****.***>

			stdErrEnc.Encode(&log.Entry{
				Level:   ErrorKind,
				Message: msg,
				Time:    time.Now().UTC(),
				Trace:   &log.Trace{Message: msg},
			})
		}
		if err := w.rotate(); err != nil {
			msg := fmt.Sprintf("unable to rotate log file %v: %v", w.f.Name(), err)
			stdErrEnc.Encode(&log.Entry{
				Level:   ErrorKind,
				Message: msg,

            for (final LockingAndXRange lockingAndXRange : this.unlocks) {
                dstIndex += lockingAndXRange.encode(dst, dstIndex);
            }
        }
        if (this.locks != null) {
            for (final LockingAndXRange lockingAndXRange : this.locks) {
                dstIndex += lockingAndXRange.encode(dst, dstIndex);
            }
        }
        return start - dstIndex;
    }

    /**