}
        }
      }
    }
    return null;
  }

  private static <T> T createEmptyArray(Class<T> arrayType) {
    // getComponentType() is non-null because we call createEmptyArray only with an array type.
    return arrayType.cast(Array.newInstance(requireNonNull(arrayType.getComponentType()), 0));
  }

    } else if (range.equals(Range.all())) {
      return all();
    } else {
      return new ImmutableRangeSet<>(ImmutableList.of(range));
    }
  }

  /** Returns an immutable range set containing the single range {@link Range#all()}. */
  @SuppressWarnings("unchecked")
  static <C extends Comparable> ImmutableRangeSet<C> all() {
    return (ImmutableRangeSet<C>) ALL;
  }

    if (deferredPlans.isNotEmpty()) return deferredPlans.removeFirst() as FakePlan

    if (nextPlanIndex >= plans.size && autoGeneratePlans) addPlan()

    require(nextPlanIndex < plans.size) {
      "not enough plans! call addPlan() or set autoGeneratePlans=true in the test to set this up"
    }
    val result = plans[nextPlanIndex++]
    events += "take plan ${result.id}"

    if (result.yieldBeforePlanReturns) {
      taskFaker.yield()

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs

      Class<?> value) {
    forward.put(key, value);
    backward.put(value, key);
  }

  /**
   * Returns an immutable set of all nine primitive types (including {@code void}). Note that a
   * simpler way to test whether a {@code Class} instance is a member of this set is to call {@link
   * Class#isPrimitive}.
   *
   * @since 3.0
   */
  public static Set<Class<?>> allPrimitiveTypes() {

        Future<?> possiblyIgnoredError =
            executorService.submit(
                () -> {
                  startLatch.countDown();
                  startLatch.await();
                  callable.call();
                  doneLatch.countDown();
                  return null;
                });
      }
      doneLatch.await();
    } finally {
      executorService.shutdown();
    }
  }

        Callable<V> callable, long delay, TimeUnit unit) {
      recordedDelay = delay;
      recordedTimeUnit = unit;
      try {
        return ImmediateScheduledFuture.of(callable.call());
      } catch (Exception e) {
        return ImmediateScheduledFuture.failed(e);
      }
    }

    @Override
    public ListenableScheduledFuture<?> scheduleAtFixedRate(

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs

        assertFalse(listener.wasShutdownCalled());

        // Call shutdown
        scriptExecutor.shutdown();

        // Verify listener was called
        assertTrue(listener.wasShutdownCalled());
    }

    @Test
    public void test_shutdown_withoutListener() {
        // Call shutdown without setting listener
        try {
            scriptExecutor.shutdown();

   * given executor at the first call to {@code addListener}. The task must be started by the
   * executor promptly, or else the returned {@code ListenableFuture} may fail to work. The task's
   * execution consists of blocking until the input future is {@linkplain Future#isDone() done}, so
   * each call to this method may claim and hold a thread for an arbitrary length of time. Use of