* the License.
 */

package com.google.common.base;

import com.google.common.annotations.GwtCompatible;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A class that can supply objects of a single type; a pre-Java-8 version of {@link
 * java.util.function.Supplier java.util.function.Supplier}. Semantically, this could be a factory,

            ? super AggregateFutureState<?>, ? super @Nullable Set<Throwable>>
        seenExceptionsUpdater;

    final AtomicIntegerFieldUpdater<? super AggregateFutureState<?>> remainingCountUpdater;

    SafeAtomicHelper(
        AtomicReferenceFieldUpdater<
                ? super AggregateFutureState<?>, ? super @Nullable Set<Throwable>>
            seenExceptionsUpdater,

import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicBoolean;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Utilities necessary for working with libraries that supply plain {@link Future} instances. Note
 * that, whenever possible, it is strongly preferred to modify those libraries to return {@code

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.features.CollectionSize;
import java.util.Collection;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * The subject-generator interface accepted by Collection testers, for testing a Collection at one
 * particular {@link CollectionSize}.
 *

 * limitations under the License.
 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;
import java.io.Serializable;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Simple base class to verify that we handle generics correctly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class BaseComparable implements Comparable<BaseComparable>, Serializable {

 */

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.J2ktIncompatible;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Hidden superclass of {@link FluentFuture} that provides us a place to declare special GWT
 * versions of the {@link FluentFuture#catching(Class, com.google.common.base.Function)

      @Override
      void assertFailsToDecode(
          BaseEncoding encoding, String cannotDecode, @Nullable String expectedMessage) {
        assertThat(encoding.canDecode(cannotDecode)).isFalse();
      }
    },
    DECODE {
      @Override
      void assertFailsToDecode(
          BaseEncoding encoding, String cannotDecode, @Nullable String expectedMessage) {
        try {
          encoding.decode(cannotDecode);

   * CollectionRemoveTester.testRemove_nullAllowed, but it's not clear that it's
   * a good policy, especially because, in order for the test to pass, the
   * parameter must be misleadingly annotated as @Nullable. I suspect that
   * we'll want to remove @Nullable, add an eager checkNotNull, and loosen up
   * testRemove_nullAllowed.
   */
  @CanIgnoreReturnValue
  @Override
  public int remove(@CheckForNull Object element, int occurrences) {

      @Override
      void assertFailsToDecode(
          BaseEncoding encoding, String cannotDecode, @Nullable String expectedMessage) {
        assertThat(encoding.canDecode(cannotDecode)).isFalse();
      }
    },
    DECODE {
      @Override
      void assertFailsToDecode(
          BaseEncoding encoding, String cannotDecode, @Nullable String expectedMessage) {
        try {
          encoding.decode(cannotDecode);

import java.math.RoundingMode;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicLongArray;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Collections of strategies of generating the k * log(M) bits required for an element to be mapped
 * to a BloomFilter of M bits and k hash functions. These strategies are part of the serialized form