*/
    public DialectVersion getDialect() {
        return this.dialect;
    }

    /**
     * Set key rotation limits
     *
     * @param bytesLimit maximum bytes to encrypt before rotation (0 to disable)
     * @param timeMillis maximum time in milliseconds before rotation (0 to disable)
     */
    public void setKeyRotationLimits(long bytesLimit, long timeMillis) {
        if (bytesLimit > 0) {

        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test size calculation with different buffer sizes")
    void testSizeCalculationWithDifferentBufferSizes() {
        // Test with smaller maximum buffer size
        when(mockConfig.getMaximumBufferSize()).thenReturn(8192);
        when(mockConfig.getListSize()).thenReturn(16384);

        request = new Smb2QueryDirectoryRequest(mockConfig);

        assertThrows(SMBProtocolDecodingException.class, () -> {
            notifyInfo.decode(buffer, 0, buffer.length);
        });
    }

    @Test
    @DisplayName("Test decode with maximum file name length")
    void testDecodeMaxFileNameLength() throws SMBProtocolDecodingException {
        // Create a very long filename (but within reasonable bounds)
        StringBuilder sb = new StringBuilder();

   */

  // Constants

  /**
   * The maximum capacity, used if a higher value is implicitly specified by either of the
   * constructors with arguments. MUST be a power of two {@code <= 1<<30} to ensure that entries are
   * indexable using ints.
   */
  static final int MAXIMUM_CAPACITY = 1 << 30;

  /** The maximum number of segments to allow; used to bound constructor arguments. */

        return OptionalEntity.empty();
    }

    /**
     * Retrieves a paginated list of character mapping items.
     *
     * @param offset the starting index for pagination (0-based)
     * @param size the maximum number of items to return
     * @return a PagingList containing the requested subset of mapping items
     */
    @Override
    public synchronized PagingList<CharMappingItem> selectList(final int offset, final int size) {

your report:

  - A descriptive title
  - Your name and affiliation (if any).
  - A description of the technical details of the vulnerabilities.
  - A minimal example of the vulnerability. It is very important to let us know
    how we can reproduce your findings. For memory corruption triggerable in
    TensorFlow models, please demonstrate an exploit against one of Alphabet's

      int expectedSize) {
    return new CompactHashSet<>(expectedSize);
  }

  /**
   * 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.LinkedHashSet based

     */
    public long getMinResponseTime() {
        long min = minResponseTime.get();
        return min == Long.MAX_VALUE ? 0 : min;
    }

    /**
     * Get maximum response time
     *
     * @return maximum response time in milliseconds
     */
    public long getMaxResponseTime() {
        return maxResponseTime.get();
    }

    /**
     * Close circuit breaker and cleanup resources

            // When & Then
            assertEquals(0L, allocInfo.getCapacity());
            assertEquals(0L, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle maximum long values")
        void shouldHandleMaximumLongValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(Long.MAX_VALUE, Long.MAX_VALUE);

            // When & Then

    public void testBoundaryConditions() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[100];

        // When & Then - test with maximum valid index
        assertEquals(0, smbComTreeDisconnect.writeParameterWordsWireFormat(buffer, 99));
        assertEquals(0, smbComTreeDisconnect.writeBytesWireFormat(buffer, 99));