assertEquals("java.util", Reflection.getPackageName(Map.Entry.class));
  }

  public void testNewProxy() throws Exception {
    Runnable runnable = Reflection.newProxy(Runnable.class, X_RETURNER);
    assertEquals("x", runnable.toString());
  }

  public void testNewProxyCantWorkOnAClass() throws Exception {
    assertThrows(

   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  static Thread newThread(String name, Runnable runnable) {
    checkNotNull(name);
    checkNotNull(runnable);
    // TODO(b/139726489): Confirm that null is impossible here.
    Thread result = requireNonNull(platformThreadFactory().newThread(runnable));
    try {
      result.setName(name);
    } catch (SecurityException e) {

  val taskRunner: TaskRunner =
    TaskRunner(
      object : TaskRunner.Backend {
        override fun execute(
          taskRunner: TaskRunner,
          runnable: Runnable,
        ) {
          taskRunner.assertLockHeld()

          val queuedTask = RunnableSerialTask(runnable)
          serialTaskQueue += queuedTask
          executeCallCount++
          isParallel = serialTaskQueue.size > 1
        }

  }

  @Override
  public void shutdown() {
    delegate().shutdown();
  }

  @Override
  @CanIgnoreReturnValue
  public List<Runnable> shutdownNow() {
    return delegate().shutdownNow();
  }

  @Override
  public void execute(Runnable command) {
    delegate().execute(command);
  }

  @Override
  public <T extends @Nullable Object> Future<T> submit(Callable<T> task) {

      return true;
    }

    @Override
    public void execute(Runnable runnable) {}

    @Override
    public <V> ListenableScheduledFuture<V> schedule(
        Callable<V> callable, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    @Override
    public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();

   */
  @Override
  ListenableScheduledFuture<?> scheduleAtFixedRate(
      Runnable command, long initialDelay, long period, TimeUnit unit);

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override
  ListenableScheduledFuture<?> scheduleWithFixedDelay(
      Runnable command, long initialDelay, long delay, TimeUnit unit);

    inBetween.assertRun();
    after.assertRun();
  }

  public void testMisbehavingListenerAlreadyDone() {
    class BadRunnableException extends RuntimeException {}

    Runnable bad =
        new Runnable() {
          @Override
          public void run() {
            throw new BadRunnableException();
          }
        };

    future.set(1);

        .addEqualityGroup(newDelegatingList(LIST2))
        .addEqualityGroup(
            newProxyWithEqualsForInterfaces(List.class, Runnable.class),
            newProxyWithEqualsForInterfaces(List.class, Runnable.class))
        .addEqualityGroup(newProxyWithEqualsForInterfaces(Runnable.class, List.class))
        .addEqualityGroup(
            newDelegatingListWithEquals(LIST1),
            newDelegatingListWithEquals(LIST1),

  }

  @Override
  public final ScheduledFuture<?> scheduleAtFixedRate(
      Runnable command, long initialDelay, long period, TimeUnit unit) {
    return delegate.scheduleAtFixedRate(wrapTask(command), initialDelay, period, unit);
  }

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

                public Integer call() {
                  return counter.incrementAndGet();
                }
              });
      CyclicBarrier barrier = new CyclicBarrier(numThreads + 1);
      Runnable wrapper =
          new Runnable() {
            @Override
            public void run() {
              awaitUnchecked(barrier);
              task.run();
              awaitUnchecked(barrier);
            }
          };