* as necessary to try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/487687332
  public static void awaitDone(Future<?> future) {
    if (future.isDone()) {
      return;
    }
    long timeoutSeconds = timeoutSeconds();

    assertThat(cache.getIfPresent(4)).isEqualTo(40);
    assertThat(cache.getIfPresent(5)).isEqualTo(50);
    assertThat(cache.getIfPresent(2)).isNull();
  }

  @SuppressWarnings({"deprecation", "LoadingCacheApply"})
  @Test
  public void loadingCache() throws ExecutionException {
    CacheLoader<Integer, Integer> loader =
        new CacheLoader<Integer, Integer>() {
          int i = 0;

 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionStreamTester<E> extends AbstractCollectionTester<E> {
  /*
   * We're not really testing the implementation of Stream, only that we're getting a Stream

import org.jspecify.annotations.Nullable;

/** Implementations of {@code Futures.transform*}. */
@GwtCompatible
// Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||
@SuppressWarnings("ShortCircuitBoolean")
abstract class AbstractTransformFuture<
        I extends @Nullable Object, O extends @Nullable Object, F, T extends @Nullable Object>
    extends FluentFuture.TrustedFuture<O> implements Runnable {

import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@code ForwardingDeque}.
 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class ForwardingDequeTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Deque.class,
            new Function<Deque, Deque<?>>() {
              @Override

/**
 * Tests for {@code ForwardingListIterator}.
 *
 * @author Robert Konigsberg
 */
@NullUnmarked
public class ForwardingListIteratorTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            ListIterator.class,
            new Function<ListIterator, ListIterator<?>>() {

import java.util.Map;
import org.jspecify.annotations.NullUnmarked;

/**
 * Compare CacheBuilder and MapMaker performance, ensuring that they remain on par with each other.
 *
 * @author Nikita Sidorov
 */
@SuppressWarnings("CheckReturnValue")
@NullUnmarked
public class MapMakerComparisonBenchmark {
  private static final String TEST_KEY = "test key";
  private static final String TEST_VALUE = "test value";

  // Non-loading versions:

 * <p>
 * Implementation must have {@code equals()} and {@code hashCode()} implemented, so implementations of this interface
 * can be used as keys.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
@SuppressWarnings("checkstyle:InterfaceIsType")
public interface ProjectScope extends ExtensibleEnum {

    /**
     * Main scope.
     */
    ProjectScope MAIN = projectScope("main");

    /**
     * Test scope.

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Unit test for {@link Ints}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
@SuppressWarnings("cast") // redundant casts are intentional and harmless
public class IntsTest extends TestCase {
  private static final int[] EMPTY = {};
  private static final int[] ARRAY1 = {(int) 1};

    public SinceAnnotationRuleCurrentGradleVersionSetup(Map<String, String> currentVersion) {
        this.currentVersion = currentVersion.get("currentVersion");
    }

    @Override
    @SuppressWarnings("unchecked")
    public void execute(ViolationCheckContext context) {
        Map<String, Object> userData = (Map<String, Object>) context.getUserData();
        userData.put("currentVersion", currentVersion);
    }