*/

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.concurrent.Executor;
import org.jspecify.annotations.Nullable;

/**
 * A {@link ListenableFuture} which forwards all its method calls to another future. Subclasses
 * should override one or more methods to modify the behavior of the backing future as desired per

   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#empty}.
   *
   * @since 20.0
   */
  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  public static <E extends @Nullable Object> FluentIterable<E> of() {
    return FluentIterable.from(Collections.emptyList());
  }

  /**
   * Returns a fluent iterable containing the specified elements in order.
   *

      assertTrue(Thread.holdsLock(mutex));
      return super.containsValue(value);
    }

    @Override
    public @Nullable V get(Object key) {
      assertTrue(Thread.holdsLock(mutex));
      return super.get(key);
    }

    @Override
    public @Nullable V put(K key, V value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.put(key, value);
    }

    @Override

import java.util.Collection;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates collections, containing sample elements, to be tested.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public interface TestCollectionGenerator<E extends @Nullable Object>

 * limitations under the License.
 */

package com.google.common.collect;

import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * GWT implementation of {@link ImmutableSet} that forwards to another {@code Set} implementation.
 *
 * @author Hayward Chan
 */
@SuppressWarnings("serial") // Serialization only done in GWT.

  abstract void describeAsLowerBound(StringBuilder sb);

  abstract void describeAsUpperBound(StringBuilder sb);

  abstract @Nullable C leastValueAbove(DiscreteDomain<C> domain);

  abstract @Nullable C greatestValueBelow(DiscreteDomain<C> domain);

  /*
   * The canonical form is a BelowValue cut whenever possible, otherwise ABOVE_ALL, or

import java.io.Reader;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Reader} that concatenates multiple readers.
 *
 * @author Bin Zhu
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
final class MultiReader extends Reader {
  private final Iterator<? extends CharSource> it;
  private @Nullable Reader current;

import com.google.common.annotations.GwtCompatible;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A utility similar to {@link IteratorTester} for testing a {@link ListIterator} against a known
 * good reference implementation. As with {@code IteratorTester}, a concrete subclass must provide

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import org.jspecify.annotations.Nullable;

/**
 * This class provides default values for all Java types, as defined by the JLS.
 *
 * @author Ben Yu
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class Defaults {

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * {@link FluentFuture} that forwards all calls to a delegate.
 *
 * <h3>Extension</h3>
 *
 * If you want a class like {@code FluentFuture} but with extra methods, we recommend declaring your