List<FileNotifyInformation> result = sut.watch();

        assertSame(info, result, "Should return same list instance");
        verify(info, times(1)).clear();
        assertTrue(result.isEmpty(), "List should be cleared");
    }

    // Parameterized test to exercise SMB2 with different recursive and filter values
    @ParameterizedTest(name = "SMB2 param: recursive={0}, filter={1}")

    return new FilterReader(reader) {
      @Override
      public int read(char[] cbuf, int off, int len) throws IOException {
        // if a buffer isn't being cleared correctly, this method will eventually start being called
        // with a len of 0 forever
        if (len <= 0) {
          fail("read called with a len of " + len);
        }

    return new FilterReader(reader) {
      @Override
      public int read(char[] cbuf, int off, int len) throws IOException {
        // if a buffer isn't being cleared correctly, this method will eventually start being called
        // with a len of 0 forever
        if (len <= 0) {
          fail("read called with a len of " + len);
        }

        AuthenticationRateLimiter.RateLimiterStats stats = rateLimiter.getStats();
        assertTrue(stats.getActiveAccounts() > 0);

        // Reset
        rateLimiter.reset();

        // State should be cleared
        stats = rateLimiter.getStats();
        assertEquals(0, stats.getTotalBlocked());
        assertEquals(0, stats.getAccountsLocked());
        assertEquals(0, stats.getIpsBlocked());

      executorService.execute(
          () -> {
            lock.lock();
            try {
              startUp();
              /*
               * requireNonNull is safe because executorService is never cleared after the
               * assignment above.
               */
              requireNonNull(executorService);
              runningTask = scheduler().schedule(delegate, executorService, task);

    totalSize -= collection.size();
    collection.clear();

    return unmodifiableCollectionSubclass(output);
  }

  <E extends @Nullable Object> Collection<E> unmodifiableCollectionSubclass(
      Collection<E> collection) {
    return Collections.unmodifiableCollection(collection);
  }

  @Override
  public void clear() {
    // Clear each collection, to make previously returned collections empty.

	// in CP-437 (which is mostly compatible with ASCII), unless the UTF-8
	// flag bit is set. However, there are several problems:
	//
	//	* Many ZIP readers still do not support UTF-8.
	//	* If the UTF-8 flag is cleared, several readers simply interpret the
	//	name and comment fields as whatever the local system encoding is.
	//
	// In order to avoid breaking readers without UTF-8 support,

        }
        /*
         * requireNonNull is safe: The first call to this method always enters the !hasNext() case
         * and populates currentKey, after which it's never cleared.
         */
        return immutableEntry(requireNonNull(currentKey), valueItr.next());
      }
    };
  }

  @Override
  Spliterator<Entry<K, V>> entrySpliterator() {

      executorService.execute(
          () -> {
            lock.lock();
            try {
              startUp();
              /*
               * requireNonNull is safe because executorService is never cleared after the
               * assignment above.
               */
              requireNonNull(executorService);
              runningTask = scheduler().schedule(delegate, executorService, task);

    including a bug where the cache could be corrupted upon certain access
    patterns. We also fixed a bug where the cache was being cleared due to a
    corrupted journal. We've added APIs to configure a request's `Cache-Control`
    headers, and to manually clear the cache.

 *  **Request cancellation fixes.** This update fixes a bug where synchronous