/**
     * Sets an exception for this response.
     *
     * @param e the exception to set
     */
    void exception(Exception e);

    /**
     * Gets the next response in the chain.
     *
     * @return chained response
     */
    Response getNextResponse();

	return c.g.apply(ctx).CreateInBatches(r, batchSize).Error
}

type chainG[T any] struct {
	execG[T]
}

func (c chainG[T]) getInstance() *DB {
	var r T
	return c.g.apply(context.Background()).Model(r).getInstance()
}

func (c chainG[T]) with(v op) chainG[T] {
	return chainG[T]{
		execG: execG[T]{g: &g[T]{
			db:  c.g.db,
			ops: append(append([]op(nil), c.g.ops...), v),

                            negoResp.getCommonCapabilities(), curSessId, token);

                    if (chain != null) {
                        request.chain((ServerMessageBlock2) chain);
                    }

                    request.setDigest(this.digest);
                    request.setSessionId(curSessId);

                    try {

---

Mais si vous êtes curieux de cet exemple de code spécifique et que vous êtes toujours partant, voici quelques détails supplémentaires.

#### Chaîne avec `value.startswith()` { #string-with-value-startswith }

Avez-vous remarqué ? Une chaîne utilisant `value.startswith()` peut prendre un tuple, et elle vérifiera chaque valeur du tuple :

            TestServerMessageBlock2Response result = testRequest.initResponse(mockContext);

            assertNull(result);
        }

        @Test
        @DisplayName("initResponse should chain responses for chained requests")
        void testInitResponseChained() {
            TestServerMessageBlock2Response response1 = new TestServerMessageBlock2Response(mockConfig);

///

## Gérer les types et la validation { #types-and-validation }

Ces variables d'environnement ne peuvent gérer que des **chaînes de texte**, car elles sont externes à Python et doivent être compatibles avec les autres programmes et le reste du système (et même avec différents systèmes d'exploitation, comme Linux, Windows, macOS).

Vous pouvez le configurer dans votre application **FastAPI** à l’aide de `CORSMiddleware`.

* Importer `CORSMiddleware`.
* Créer une liste d’origines autorisées (sous forme de chaînes).
* L’ajouter comme « middleware » à votre application **FastAPI**.

Vous pouvez également spécifier si votre backend autorise :

* Les informations d’identification (en-têtes Authorization, cookies, etc.).

        when(nextResponse.getNextResponse()).thenReturn(thirdResponse);
        when(thirdResponse.getNextResponse()).thenReturn(null);

        // When - navigate through chain
        CommonServerMessageBlockResponse second = response.getNextResponse();
        CommonServerMessageBlockResponse third = second.getNextResponse();
        CommonServerMessageBlockResponse end = third.getNextResponse();

        // Then

Mais cela signifie que si vous vous contentez de la convertir en chaîne et de renvoyer cette information directement, vous pourriez divulguer un peu d'information sur votre système. C'est pourquoi, ici, le code extrait et affiche chaque erreur indépendamment.

///

        this(config, command, null);
    }

    /**
     * Constructs an AndX message block with command and chained command
     * @param config the configuration
     * @param command the SMB command
     * @param andx the chained command
     */
    protected AndXServerMessageBlock(final Configuration config, final byte command, final ServerMessageBlock andx) {
        super(config, command);