abstract int decrementAndGetRemainingCount(AggregateFutureState<?> state);
  }

  private static final class SafeAtomicHelper extends AtomicHelper {
    final AtomicReferenceFieldUpdater<
            ? super AggregateFutureState<?>, ? super @Nullable Set<Throwable>>
        seenExceptionsUpdater;

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

    SafeAtomicHelper(

   * method from an ancestor class.
   *
   * <p>See JLS 8.4.2 for the definition of the related "override-equivalent."
   */
  private static final class MethodSignature implements Comparable<MethodSignature> {
    final String name;
    final List<Class<?>> parameterTypes;
    final TypeSignature typeSignature;

    MethodSignature(Method method) {
      name = method.getName();

   * method from an ancestor class.
   *
   * <p>See JLS 8.4.2 for the definition of the related "override-equivalent."
   */
  private static final class MethodSignature implements Comparable<MethodSignature> {
    final String name;
    final List<Class<?>> parameterTypes;
    final TypeSignature typeSignature;

    MethodSignature(Method method) {
      name = method.getName();

  }

  private static final ByteSource BROKEN_CLOSE_SOURCE =
      new TestByteSource(new byte[10], CLOSE_THROWS);
  private static final ByteSource BROKEN_OPEN_SOURCE =
      new TestByteSource(new byte[10], OPEN_THROWS);
  private static final ByteSource BROKEN_READ_SOURCE =
      new TestByteSource(new byte[10], READ_THROWS);
  private static final ByteSink BROKEN_CLOSE_SINK = new TestByteSink(CLOSE_THROWS);

    return callables;
  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    public WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {

          {true, true, ElementOrder.insertion(), ElementOrder.insertion()},
        });
  }

  private final boolean allowsSelfLoops;
  private final boolean allowsParallelEdges;
  private final ElementOrder<Integer> nodeOrder;
  private final ElementOrder<String> edgeOrder;

  private ImmutableNetwork.Builder<Integer, String> networkBuilder;

  public StandardImmutableDirectedNetworkTest(

    return MinimalCollection.<E>of();
  }

  protected final E e0() {
    return samples.e0();
  }

  protected final E e1() {
    return samples.e1();
  }

  protected final E e2() {
    return samples.e2();
  }

  protected final E e3() {
    return samples.e3();
  }

  protected final E e4() {
    return samples.e4();
  }

          {true, true, ElementOrder.insertion(), ElementOrder.insertion()},
        });
  }

  private final boolean allowsSelfLoops;
  private final boolean allowsParallelEdges;
  private final ElementOrder<Integer> nodeOrder;
  private final ElementOrder<String> edgeOrder;

  public StandardMutableUndirectedNetworkTest(
      boolean allowsSelfLoops,
      boolean allowsParallelEdges,

abstract class WrappingScheduledExecutorService extends WrappingExecutorService
    implements ScheduledExecutorService {
  final ScheduledExecutorService delegate;

  protected WrappingScheduledExecutorService(ScheduledExecutorService delegate) {
    super(delegate);
    this.delegate = delegate;
  }

  @Override
  public final ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {

 */
@Deprecated(since = "4.0.0")
class DefaultTransformerContextBuilder implements TransformerContextBuilder {
    private final Graph dag = new Graph();
    private final DefaultModelBuilder defaultModelBuilder;
    private final DefaultTransformerContext context;

    private final Map<String, Set<FileModelSource>> mappedSources = new ConcurrentHashMap<>(64);

    private volatile boolean fullReactorLoaded;