}
        },
        directExecutor());
    manager.startAsync();
    afterStarted.countDown();
    // We do not call awaitHealthy because, due to races, that method may throw an exception.  But
    // we really just want to wait for the thread to be in the failure callback so we wait for that
    // explicitly instead.
    failEnter.await();
    assertFalse("State should be updated before calling listeners", manager.isHealthy());

         * the new one. The result is a ConcurrentModificationException or other bad behavior.
         *
         * (If we decide that we really, really hate allocating two Iterators per cycle instead of
         * one, we can optimistically store the new Iterator and then be willing to throw it out if
         * the user calls remove().)
         */

  public void testSplitterIterableIsLazy_pattern() {
    if (!CommonPattern.isPcreLike()) {
      return;
    }
    assertSplitterIterableIsLazy(Splitter.onPattern(","));
  }

  /**
   * This test really pushes the boundaries of what we support. In general the splitter's behaviour
   * is not well defined if the char sequence it's splitting is mutated during iteration.
   */

    try {
      builder.buildOrThrow();
      fail("Expected exception from duplicate keys");
    } catch (IllegalArgumentException expected) {
      // We don't really care which values the exception message contains, but they should be
      // different from each other. If buildKeepingLast() collapsed duplicates, that might end up
      // not being true.

   * going through {@code FluentIterable} at all), the more performant and idiomatic your code will
   * be. This method is a transitional aid, to be used only when really necessary.
   *
   * @since 21.0
   */
  public final Stream<E> stream() {
    return Streams.stream(getDelegate());
  }

  /** Function that transforms {@code Iterable<E>} into a fluent iterable. */

   *
   * <p><b>{@code Stream} equivalent:</b> {@code
   * stream.filter(predicate).findFirst().orElse(defaultValue)}
   *
   * @since 7.0
   */
  // The signature we really want here is...
  //
  // <T extends @Nullable Object> @JointlyNullable T find(
  //     Iterable<? extends T> iterable,
  //     Predicate<? super T> predicate,
  //     @JointlyNullable T defaultValue);
  //

        return this.bimap.equals(that.bimap);
      }
      return false;
    }

    @Override
    public int hashCode() {
      return bimap.hashCode();
    }

    // There's really no good way to implement toString() without printing the entire BiMap, right?
    @Override
    public String toString() {
      return "Maps.asConverter(" + bimap + ")";
    }

  private static final class LegacyAsyncDispatcher extends Dispatcher {

    // This dispatcher matches the original dispatch behavior of AsyncEventBus.
    //
    // We can't really make any guarantees about the overall dispatch order for this dispatcher in
    // a multithreaded environment for a couple of reasons:
    //

      </plugin>
      <plugin>
        <artifactId>maven-source-plugin</artifactId>
        <configuration>
          <excludes>
            <!-- 3. Don't include it in the source jar (since it's really more of a "test" than it is production code). -->
            <exclude>**/ForceGuavaCompilation*</exclude>
            <exclude>**/DummyJavadocClass*</exclude>
          </excludes>
        </configuration>

   *
   * - Define putIfAbsent and replace as treating zero and absent identically (as currently
   *   implemented below). This is a bit surprising with putIfAbsent, which really becomes
   *   putIfZero.
   *
   * - Allow putIfAbsent and replace to distinguish between zero and absent, but don't implement
   *   remove(K, long). Without any two-phase operations it becomes feasible for all remaining