assertEquals(0, response.readBytesWireFormat(null, 0), "Should read 0 bytes");
    }

    /* ------------------------------------------------------------------ */
    /* 4. State verification after operations                             */
    /* ------------------------------------------------------------------ */

    @Test
    @DisplayName("Multiple reads update offset correctly")

        // Assert
        assertNotNull(handle);
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
        // Further verification could involve capturing the MsrpcLsarOpenPolicy2 argument and checking its server field.
    }

    @Test
    void constructor_shouldThrowSmbExceptionOnRpcError() throws IOException {
        // Arrange

        // Verify negotiate context offset is set
        int contextOffset = SMBUtil.readInt4(buffer, 28);
        assertTrue(contextOffset > 0);

        // Skip detailed context verification since we can't access headerStart
        // Just verify that contexts were written
        assertTrue(bytesWritten > 60); // Should be larger than basic negotiate request
    }

    @Test

<img src="/img/tutorial/body/image03.png">

Et vous obtenez aussi de la vérification d'erreur pour les opérations incorrectes de types :

<img src="/img/tutorial/body/image04.png">

Ce n'est pas un hasard, ce framework entier a été bâti avec ce design comme objectif.

Toutes les fonctionnalités qui s'appliquent aux paramètres de chemin s'appliquent aussi aux paramètres de requête :

* Support de l'éditeur : vérification d'erreurs, auto-complétion, etc.
* <abbr title="conversion de la chaîne de caractères venant de la requête HTTP en données Python">"Parsing"</abbr> de données.
* Validation de données.

                break;
            }
        }
        assertEquals(true, different, "Different data should produce different HMAC values");
    }

    // Helper method to manually calculate HMACT64 for verification
    private byte[] calculateHMACT64Manually(byte[] key, byte[] data) throws NoSuchAlgorithmException {
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        byte[] ipad = new byte[64];

        // Act: call methods, some multiple times
        String name = mockEntry.getName();
        int type1 = mockEntry.getType();
        int type2 = mockEntry.getType(); // called twice for interaction verification
        int attributes = mockEntry.getAttributes();
        long createTime = mockEntry.createTime();
        long lastModified = mockEntry.lastModified();
        long lastAccess = mockEntry.lastAccess();

    @Test
    @DisplayName("Constructor with delegate: acquire() forwards to delegate and release() too")
    void constructor_withDelegate_acquireAndReleaseForwarded() {
        // Arrange: delegate we can spy on for interaction verification
        CIFSContext ctx = mock(CIFSContext.class);
        SmbTreeConnectionTrace delegate = Mockito.spy(new SmbTreeConnectionTrace(ctx));

        // Act: create wrapper using delegate, then acquire and release once

                 * junk. We need to bump up the wordCount here so that this method returns
                 * the correct number of bytes for signing purposes. Otherwise we get a
                 * signing verification failure.
                 */
                if (command == SMB_COM_NT_CREATE_ANDX && ((SmbComNTCreateAndXResponse) this).isExtended) {
                    wordCount += 8;
                }
            }

                if (resp instanceof SmbComTransactionResponse) {
                    ((SmbComTransactionResponse) resp).nextElement();
                }
            }

            /* Verification fails (w/ W2K3 server at least) if status is not 0. This
             * suggests MS doesn't compute the signature (correctly) for error responses
             * (perhaps for DOS reasons).
             */