assertEquals(2000, intervalControlHelper.getDelay());

        intervalControlHelper.ruleList.clear();

        intervalControlHelper.addIntervalRule("12:15", "12:15", "*", 3000);
        assertEquals(3000, intervalControlHelper.getDelay());

        intervalControlHelper.ruleList.clear();

        intervalControlHelper.addIntervalRule("12:15", "12:15", "3,5", 4000);

     */
    public DocList() {
        super();
    }

    /**
     * Clears all documents from the list and resets metrics.
     * Removes all documents and resets content size and processing time to zero.
     */
    @Override
    public void clear() {
        super.clear();
        contentSize = 0;
        processingTime = 0;
    }

    /**

    return delegate.ceilingEntry(checkValid(key));
  }

  @Override
  public @Nullable K ceilingKey(K key) {
    return delegate.ceilingKey(checkValid(key));
  }

  @Override
  public void clear() {
    delegate.clear();
  }

  @Override
  public Comparator<? super K> comparator() {
    Comparator<? super K> comparator = delegate.comparator();
    if (comparator == null) {

    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearHeadOpen() {
    List<Entry<E>> expected =
        copyToList(sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet());
    sortedMultiset.headMultiset(b.getElement(), OPEN).clear();

    assertMultimapRemainsUnmodified(multimap, originalEntries);

    Collection<V> sampleValueAsCollection = singleton(sampleValue);

    // Test #clear()
    try {
      multimap.clear();
      fail("clear succeeded on unmodifiable multimap");
    } catch (UnsupportedOperationException expected) {
    }

    assertMultimapRemainsUnmodified(multimap, originalEntries);

    for (Entry<Range<K>, ? extends V> entry : rangeMap.asMapOfRanges().entrySet()) {
      put(entry.getKey(), entry.getValue());
    }
  }

  @Override
  public void clear() {
    entriesByLowerBound.clear();
  }

  @Override
  public Range<K> span() {
    Entry<Cut<K>, RangeMapEntry<K, V>> firstEntry = entriesByLowerBound.firstEntry();

(_Please use [discuss.codelibs.org](https://discuss.codelibs.org/c/FessEN/8) before filing a bug._)

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**

  @BeforeExperiment
  protected void setUp() {
    BitSet bitSet = new BitSet();
    for (int i = 0; i < OLD_WHITESPACE_TABLE.length(); i++) {
      bitSet.set(OLD_WHITESPACE_TABLE.charAt(i));
    }
    bitSet.clear(0);
    bitSet.clear(1);
    matcher = useNew ? CharMatcher.whitespace() : OLD_WHITESPACE;
    teststring = newTestString(new Random(1), bitSet, percentMatching);
  }

  @Benchmark
  public int countIn(int reps) {

    public boolean remove(final Object o) {
        return map.remove(o) == PRESENT;
    }

    /**
     * Removes all of the elements from this set.
     */
    @Override
    public void clear() {
        map.clear();
    }

    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }

  @Override
  protected TreeBasedTable<String, Integer, Character> create(@Nullable Object... data) {
    TreeBasedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("foo", 4, 'a');
    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }