}
        }

        @Override
        public int hashCode() {
            return this.keys.hashCode();
        }
    }

    /**
     * chains a collection of {@link WorkspaceReader}s
     * @param workspaceReaderCollection the collection of readers, might be empty but never <code>null</code>

        }
    }

    @Nested
    @DisplayName("Chain Tests")
    class ChainTests {

        @Test
        @DisplayName("Should chain messages successfully")
        void testChain() {
            TestServerMessageBlock2 nextMessage = new TestServerMessageBlock2(mockConfig);
            assertTrue(testMessage.chain(nextMessage));
            assertEquals(nextMessage, testMessage.getNext());

     * @return create cancel request
     */
    CommonServerMessageBlockRequest createCancel();

    /**
     * Checks if chaining is allowed with the next request.
     *
     * @param next the next request in the chain
     * @return whether to allow chaining
     */
    boolean allowChain(CommonServerMessageBlockRequest next);

    /**
     * Sets the tree ID.
     *
     * @param t the tree ID to set
     */

        this.mid = mid;
    }

    /**
     * Chains another message to this message for compound operations.
     *
     * @param n the message to chain
     * @return whether chaining was successful
     */
    public boolean chain(final ServerMessageBlock2 n) {
        if (this.next != null) {
            return this.next.chain(n);
        }

        n.addFlags(SMB2_FLAGS_RELATED_OPERATIONS);

    /**
     * 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();

   * Since Quantiles provides a fluent-style API, each test covers a chain of methods resulting in
   * the computation of one or more quantiles (or in an error) rather than individual methods. The
   * tests are divided into three sections:
   * 1. Tests on a hardcoded dataset for chains starting with median(), quartiles(), and scale(10);
   * 2. Tests on hardcoded datasets include non-finite values for chains starting with scale(10);

   * Since Quantiles provides a fluent-style API, each test covers a chain of methods resulting in
   * the computation of one or more quantiles (or in an error) rather than individual methods. The
   * tests are divided into three sections:
   * 1. Tests on a hardcoded dataset for chains starting with median(), quartiles(), and scale(10);
   * 2. Tests on hardcoded datasets include non-finite values for chains starting with scale(10);

    /**
     * Checks if this is a cancel request.
     *
     * @return whether this is a cancel request
     */
    boolean isCancel();

    /**
     * Gets the next request in the chain.
     *
     * @return chained request
     */
    Request getNext();

    /**
     * Gets the response for this request.
     *
     * @return the response for this request
     */
    Response getResponse();

```

/// check | vérifier

Comme vous l'avez remarqué, la valeur reçue par la fonction (et renvoyée ensuite) est `3`,
en tant qu'entier (`int`) Python, pas la chaîne de caractères (`string`) `"3"`.

Grâce aux déclarations de types, **FastAPI** fournit du
<abbr title="conversion de la chaîne de caractères venant de la requête HTTP en données Python">"parsing"</abbr> automatique.

///

## Validation de données

        assertEquals(block.useUnicode, next.useUnicode, "useUnicode must be propagated");
        assertTrue(next.writeParamCalls > 0, "chained SMB parameter words should be written");
        assertTrue(next.writeBytesCalls > 0, "chained SMB bytes should be written");
    }

    @Test
    @DisplayName("decode basic AndX block with no chaining")
    void testDecodeBasicNoAndx() {