// The decode method returns only the header size (16 bytes)
        assertEquals(16, bytesDecoded);
    }

    @Test
    @DisplayName("Test decode with maximum values")
    void testDecodeWithMaxValues() throws SMBProtocolDecodingException {
        // Prepare test data with max values
        byte[] buffer = new byte[20]; // 16 header + 4 data
        int bufferIndex = 0;

        // When
        request.setTid(tid);

        // Then
        verify(request, times(1)).setTid(tid);
    }

    @Test
    @DisplayName("Test setTid with maximum integer value")
    void testSetTidWithMaxValue() {
        // Given
        int tid = Integer.MAX_VALUE;
        doNothing().when(request).setTid(tid);

        // When
        request.setTid(tid);

            assertEquals(newFilename, actualFilename);
        }
    }

    @Test
    void testLargeBatchParameters() {
        // Test with maximum allowed values
        int maxSid = 0xFFFF;
        int maxResumeKey = 0x7FFFFFFF;
        int maxBatchCount = 65535;
        int maxBatchSize = 65535;

     *
     * @param b the buffer into which the data is read
     * @param off the start offset in the array b at which the data is written
     * @param len the maximum number of bytes to read
     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */

        // Should not include SMB202 or SMB210
        for (int dialect : dialects) {
            assertTrue(dialect >= 0x0300);
        }
    }

    @Test
    @DisplayName("Should handle null maximum version")
    void testNullMaximumVersion() {
        // Given
        when(mockConfig.getMaximumVersion()).thenReturn(null);

        // When/Then - Should throw NPE based on actual implementation

        assertTrue(result.contains("filter=0x" + Hexdump.toHexString(completionFilter, 4)));
        assertTrue(result.contains("watchTree=" + watchTree));
    }

    @Test
    @DisplayName("Test toString method with maximum values")
    void testToStringMaxValues() {
        int fid = 0xFFFF;
        int completionFilter = 0xFFFFFFFF;
        boolean watchTree = true;

labels.includedUrls=URL incluses pour l'exploration
labels.includedDocPaths=Chemins inclus pour la recherche
labels.includedDocUrls=URL incluses pour la recherche
labels.maxAccessCount=Nombre d'accès maximum
labels.name=Nom
labels.numOfThread=Nombre de threads
labels.duplicateHostName=Nom d'hôte en double
labels.pageNumber=Numéro de page
labels.password=Mot de passe
labels.paths=Chemins
labels.port=Port

        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum supported hash algorithms and salt")
        void testMaximumHashAlgosAndSalt() throws SMBProtocolDecodingException {
            int maxAlgos = 100;
            int[] hashAlgos = new int[maxAlgos];

            assertEquals(4, read2);
        }
    }

    @Nested
    @DisplayName("Edge case tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum buffer index")
        void testMaxBufferIndex() throws SMBProtocolDecodingException {
            // Given
            int bufferSize = 10000;
            byte[] buffer = new byte[bufferSize];

  }

  private static final Object NOT_FOUND = new Object();

  /**
   * Maximum allowed false positive probability of detecting a hash flooding attack given random
   * input.
   */
  @VisibleForTesting(
      )
  static final double HASH_FLOODING_FPP = 0.001;

  /**
   * Maximum allowed length of a hash table bucket before falling back to a j.u.LinkedHashMap-based