*
 * @author Louis Wasserman
 */
@NullUnmarked
public class IntMathRoundingBenchmark {
  private static final int[] positive = new int[ARRAY_SIZE];
  private static final int[] nonzero = new int[ARRAY_SIZE];
  private static final int[] ints = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {

 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class BigIntegerMathRoundingBenchmark {
  private static final BigInteger[] nonzero1 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] nonzero2 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] positive = new BigInteger[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

/**
 * Used to test listenable future implementations.
 *
 * @author Sven Mawson
 */
@NullUnmarked
public class ListenableFutureTester {

  private final ExecutorService exec;
  private final ListenableFuture<?> future;
  private final CountDownLatch latch;

  public ListenableFutureTester(ListenableFuture<?> future) {
    this.exec = newCachedThreadPool();
    this.future = checkNotNull(future);

 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services} instead
 */
@Deprecated(since = "4.0.0")
public class StringSource implements Source {
    private final String content;

    private final String location;

    private final int hashCode;

    /**
     * Creates a new source backed by the specified string.
     *
     * @param content The String representation, may be empty or {@code null}.
     */

 *
 *
 */
@Deprecated
public enum ArtifactScopeEnum {
    compile(1),
    test(2),
    runtime(3),
    provided(4),
    system(5),
    runtime_plus_system(6);

    public static final ArtifactScopeEnum DEFAULT_SCOPE = compile;

    private int id;

    // Constructor
    ArtifactScopeEnum(int id) {
        this.id = id;
    }

    int getId() {
        return id;
    }

/**
 * The credential for action response.
 */
public class ActionResponseCredential implements LoginCredential {

    private final Supplier<ActionResponse> action;

    /**
     * Constructor.
     * @param action The action.
     */
    public ActionResponseCredential(final Supplier<ActionResponse> action) {
        this.action = action;
    }

    /**
     * Execute the action.

 */
public class BadPaddingRuntimeException extends ClRuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * Creates a new {@link BadPaddingRuntimeException} with the specified cause.
     *
     * @param cause
     *            the cause
     */
    public BadPaddingRuntimeException(final BadPaddingException cause) {
        super("ECL0105", new Object[] { cause.getMessage() }, cause);
    }

      assertTrue(Arrays.equals(Arrays.copyOf(hashBytes, bytes), bb));
    }
  }

  private static class ExpectedHashCode {
    final byte[] bytes;
    final int asInt;
    final Long asLong; // null means that asLong should throw an exception
    final String toString;

    ExpectedHashCode(byte[] bytes, int asInt, @Nullable Long asLong, String toString) {
      this.bytes = bytes;
      this.asInt = asInt;

    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {
    private final Deque<E> delegate = new LinkedList<>();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));

    throw new InvalidObjectException("Use SerializedForm");
  }

  private static final class SerialForm<T extends @Nullable Object> implements Serializable {
    final long[] data;
    final int numHashFunctions;
    final Funnel<? super T> funnel;
    final Strategy strategy;

    SerialForm(BloomFilter<T> bf) {
      this.data = LockFreeBitArray.toPlainArray(bf.bits.data);