*     source-compatible</a> since 9.0)
 */
@GwtCompatible
public abstract class Ticker {
  /** Constructor for use by subclasses. */
  protected Ticker() {}

  /** Returns the number of nanoseconds elapsed since this ticker's fixed point of reference. */
  public abstract long read();

  /**
   * A ticker that reads the current time using {@link System#nanoTime}.
   *
   * @since 10.0

  // so that we can then report them during tearDown.

  abstract class CheckedRunnable implements Runnable {
    abstract void realRun() throws Throwable;

    @Override
    public final void run() {
      try {
        realRun();
      } catch (Throwable t) {
        threadUnexpectedException(t);
      }
    }
  }

  abstract class CheckedCallable<T> implements Callable<T> {

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * An abstract {@code ExecutorService} that allows subclasses to {@linkplain #wrapTask(Callable)
 * wrap} tasks before they are submitted to the underlying executor.
 *
 * <p>Note that task wrapping may occur even if the task is never executed.

package com.google.common.util.concurrent;

import static com.google.common.collect.Sets.newHashSet;

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

/** Emulation of AggregateFutureState. */
abstract class AggregateFutureState<OutputT extends @Nullable Object>
    extends AbstractFuture.TrustedFuture<OutputT> {
  // Lazily initialized the first time we see an exception; not released until all the input futures

import org.jspecify.annotations.Nullable;

/**
 * An abstract composition of multiple hash functions. {@linkplain #newHasher()} delegates to the
 * {@code Hasher} objects of the delegate hash functions, and in the end, they are used by
 * {@linkplain #makeHash(Hasher[])} that constructs the final {@code HashCode}.
 *
 * @author Dimitris Andreou
 */
@Immutable
abstract class AbstractCompositeHashFunction extends AbstractHashFunction {

   */
  abstract long queryEarliestAvailable(long nowMicros);

  /**
   * Reserves the requested number of permits and returns the time that those permits can be used
   * (with one caveat).
   *
   * @return the time that the permits may be used, or, if the permits may be used immediately, an
   *     arbitrary past or present time
   */

      }
    };
  }

  // Implementations for encoding/decoding

  abstract int maxEncodedSize(int bytes);

  abstract void encodeTo(Appendable target, byte[] bytes, int off, int len) throws IOException;

  abstract int maxDecodedSize(int chars);

  abstract int decodeTo(byte[] target, CharSequence chars) throws DecodingException;

        "sec:dependency-mgmt-in-gradle"
    ));

    @InputDirectory
    @PathSensitive(PathSensitivity.RELATIVE)
    public abstract DirectoryProperty getDocumentationRoot();

    @InputDirectory
    @PathSensitive(PathSensitivity.RELATIVE)
    public abstract DirectoryProperty getJsonFilesDirectory();

    @TaskAction
    public void checkMissingFiles() {

package mockwebserver3

import java.io.Closeable

/** Handler for mock server requests. */
public abstract class Dispatcher : Closeable {
  /**
   * Returns a response to satisfy `request`. This method may block (for instance, to wait on
   * a CountdownLatch).
   */
  @Throws(InterruptedException::class)
  public abstract fun dispatch(request: RecordedRequest): MockResponse

  /**

import java.util.List;
import org.jspecify.annotations.NullMarked;

/**
 * Create multisets of strings for tests.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public abstract class TestStringMultisetGenerator implements TestMultisetGenerator<String> {
  @Override
  public SampleElements<String> samples() {
    return new Strings();
  }

  @Override