import org.checkerframework.checker.nullness.qual.Nullable;

/** Replacements for JUnit's {@code assertThrows} that work under GWT/J2CL. */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class ReflectionFreeAssertThrows {
  interface ThrowingRunnable {
    void run() throws Throwable;
  }

  interface ThrowingSupplier {
    @Nullable Object get() throws Throwable;
  }

  @CanIgnoreReturnValue

import junit.framework.TestSuite;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a List
 * implementation.
 *
 * @author George van den Driessche
 */
@GwtIncompatible
public final class ListTestSuiteBuilder<E>
    extends AbstractCollectionTestSuiteBuilder<ListTestSuiteBuilder<E>, E> {
  public static <E> ListTestSuiteBuilder<E> using(TestListGenerator<E> generator) {

/**
 * Tests of basic {@link LoadingCache} operations with all possible combinations of key & value
 * strengths.
 *
 * @author mike nonemacher
 */
public class CacheReferencesTest extends TestCase {

  private static final CacheLoader<Key, String> KEY_TO_STRING_LOADER =
      new CacheLoader<Key, String>() {
        @Override
        public String load(Key key) {
          return key.toString();
        }
      };

import org.slf4j.Marker;

import static java.util.Objects.requireNonNull;

/**
 * @since 3.1.0
 */
public class Slf4jStdoutLogger implements Logger {
    private static final String ERROR = "[ERROR] ";

    private final PrintStream out;

    public Slf4jStdoutLogger() {
        this(System.out);
    }

    public Slf4jStdoutLogger(PrintStream out) {
        this.out = requireNonNull(out);
    }

 *
 * <p>As an example, imagine that we have a list of tasks to execute, but we don't want to submit
 * more than 2 per second:
 *
 * <pre>{@code
 * final RateLimiter rateLimiter = RateLimiter.create(2.0); // rate is "2 permits per second"
 * void submitTasks(List<Runnable> tasks, Executor executor) {
 *   for (Runnable task : tasks) {
 *     rateLimiter.acquire(); // may wait

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * maven dependency metadata graph
 *
 *
 */
@Deprecated
public class MetadataGraph {
    public static final int DEFAULT_VERTICES = 32;
    public static final int DEFAULT_EDGES = 64;

    // flags to indicate the granularity of vertices
    private boolean versionedVertices = false;
    private boolean scopedVertices = false;
    /**

 */
@ElementTypesAreNonnullByDefault
@GwtCompatible(emulated = true)
public class BytesTest extends TestCase {
  private static final byte[] EMPTY = {};
  private static final byte[] ARRAY1 = {(byte) 1};
  private static final byte[] ARRAY234 = {(byte) 2, (byte) 3, (byte) 4};

  private static final byte[] VALUES = {Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE};

  public void testHashCode() {
    for (byte value : VALUES) {

    }
  }

  private static final ImmutableRangeSet<Integer> RANGE_SET_ONE =
      ImmutableRangeSet.<Integer>builder()
          .add(Range.closed(2, 4))
          .add(Range.open(6, 7))
          .add(Range.closedOpen(8, 10))
          .add(Range.openClosed(15, 17))
          .build();

  private static final ImmutableRangeSet<Integer> RANGE_SET_TWO =

 *
 * @author Kevin Bourrillion
 * @author Louis Wasserman
 */
public class UnsignedBytesTest extends TestCase {
  private static final byte LEAST = 0;
  private static final byte GREATEST = (byte) 255;

  // Only in this class, VALUES must be strictly ascending
  private static final byte[] VALUES = {LEAST, 127, (byte) 128, (byte) 129, GREATEST};

  public void testToInt() {

  public enum Value {
    INSTANCE;
  }

  public enum ListSizeDistribution {
    UNIFORM_0_TO_2(0, 2),
    UNIFORM_0_TO_9(0, 9),
    ALWAYS_0(0, 0),
    ALWAYS_10(10, 10);

    final int min;
    final int max;

    private ListSizeDistribution(int min, int max) {
      this.min = min;
      this.max = max;
    }

    public int chooseSize(Random random) {