* someone still manages to pass null, let's continue to have the method work.
   *
   * (PatternFilenameFilter is of course one of those classes that shouldn't be a publicly visible
   * class to begin with but rather something returned from a static factory method whose declared
   * return type is plain FilenameFilter. If we made such a change, then the annotation we choose

    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}

    @SuppressWarnings("unused") // accessed reflectively
    void testNotPublic() {}
  }

  // Shouldn't be mistaken as Foo's test
  static class Foo2Test {
    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}
  }

  private List<Class<?>> findClassesToTest(

    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}

    @SuppressWarnings("unused") // accessed reflectively
    void testNotPublic() {}
  }

  // Shouldn't be mistaken as Foo's test
  static class Foo2Test {
    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}
  }

  private List<Class<?>> findClassesToTest(

  /**
   * RegularImmutableAsList should assume its input is null-free without checking, because it only
   * gets invoked from other immutable collections.
   */
  public void testDoesntCheckForNull() {
    ImmutableSet<Integer> set = ImmutableSet.of(1, 2, 3);
    ImmutableList<Integer> unused =
        new RegularImmutableAsList<Integer>(set, new @Nullable Object[] {null, null, null});
    // shouldn't throw!
  }

      helper = new SynchronizedAtomicHelper();
    }
    ATOMIC_HELPER = helper;
    // Log after all static init is finished; if an installed logger uses any Futures methods, it
    // shouldn't break in cases where reflection is missing/broken.
    if (thrownReflectionFailure != null) {
      log.get().log(Level.SEVERE, "SafeAtomicHelper is broken!", thrownReflectionFailure);
    }
  }

    ImmutableNetwork.Builder<String, Integer> immutableNetworkBuilder =
        networkBuilder.<String, Integer>immutable();

    // Update NetworkBuilder, but this shouldn't impact immutableNetworkBuilder
    networkBuilder.allowsSelfLoops(false).nodeOrder(ElementOrder.<String>unordered());

    ImmutableNetwork<String, Integer> emptyNetwork = immutableNetworkBuilder.build();

    ImmutableValueGraph.Builder<String, Integer> immutableValueGraphBuilder =
        graphBuilder.<String, Integer>immutable();

    // Update ValueGraphBuilder, but this shouldn't impact immutableValueGraphBuilder
    graphBuilder.allowsSelfLoops(false).nodeOrder(ElementOrder.<String>unordered());

    ImmutableValueGraph<String, Integer> emptyGraph = immutableValueGraphBuilder.build();

  /**
   * RegularImmutableAsList should assume its input is null-free without checking, because it only
   * gets invoked from other immutable collections.
   */
  public void testDoesntCheckForNull() {
    ImmutableSet<Integer> set = ImmutableSet.of(1, 2, 3);
    ImmutableList<Integer> unused =
        new RegularImmutableAsList<Integer>(set, new @Nullable Object[] {null, null, null});
    // shouldn't throw!
  }

   *
   * Note that sometimes these fields *do* have correct values under J2CL: They will if the caller
   * calls `create(Foo.class)`, rather than `create(map)`. That's fine; we just shouldn't rely on
   * it.
   */
  transient Class<K> keyTypeOrObjectUnderJ2cl;
  transient Class<V> valueTypeOrObjectUnderJ2cl;

  /**
   * Returns a new, empty {@code EnumBiMap} using the specified key and value types.

            .allowsSelfLoops(true)
            .<String>nodeOrder(ElementOrder.<String>natural());
    ImmutableGraph.Builder<String> immutableGraphBuilder = graphBuilder.immutable();

    // Update GraphBuilder, but this shouldn't impact immutableGraphBuilder
    graphBuilder.allowsSelfLoops(false).nodeOrder(ElementOrder.<String>unordered());

    ImmutableGraph<String> emptyGraph = immutableGraphBuilder.build();