*/
  protected ScheduledExecutorService executor() {
    @WeakOuter
    class ThreadFactoryImpl implements ThreadFactory {
      @Override
      public Thread newThread(Runnable runnable) {
        return MoreExecutors.newThread(serviceName(), runnable);
      }
    }
    final ScheduledExecutorService executor =
        Executors.newSingleThreadScheduledExecutor(new ThreadFactoryImpl());

/**
 * Tests for ThreadFactoryBuilder.
 *
 * @author Kurt Alfred Kluever
 * @author Martin Buchholz
 */
public class ThreadFactoryBuilderTest extends TestCase {
  private final Runnable monitoredRunnable =
      new Runnable() {
        @Override
        public void run() {
          completed = true;
        }
      };

  private static final UncaughtExceptionHandler UNCAUGHT_EXCEPTION_HANDLER =

        }
      };
  private static final Runnable GOOD_RUNNABLE =
      new Runnable() {
        @Override
        public void run() {
          try {
            MILLISECONDS.sleep(DELAY_MS);
          } catch (InterruptedException e) {
            throw new RuntimeException(e);
          }
        }
      };
  private static final Runnable BAD_RUNNABLE =
      new Runnable() {
        @Override

public class CommonPoolUtil {
    private static final Logger logger = Logger.getLogger(CommonPoolUtil.class);

    private CommonPoolUtil() {
        // nothing
    }

    public static void execute(final Runnable task) {
        ForkJoinPool.commonPool().execute(() -> {
            final Thread currentThread = Thread.currentThread();
            final ClassLoader orignal = currentThread.getContextClassLoader();

    }
  }

  // This exclusion doesn't exclude the TOMBSTONE objects we set. So 'done' NEW futures will look
  // larger than they are.
  @SuppressWarnings("FutureReturnValueIgnored")
  @Footprint(exclude = {Runnable.class, Executor.class, Thread.class, Exception.class})
  public Object measureSize() {
    for (Thread thread : blockedThreads) {
      thread.interrupt();
    }
    blockedThreads.clear();

          @Override
          public String get(long time, TimeUnit unit) {
            return "foo"; // BAD!!
          }

          @Override
          public void addListener(Runnable runnable, Executor executor) {
            executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",

          @Override
          public String get(long time, TimeUnit unit) {
            return "foo"; // BAD!!
          }

          @Override
          public void addListener(Runnable runnable, Executor executor) {
            executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",

  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(

    AtomicLong count = (nameFormat != null) ? new AtomicLong(0) : null;
    return new ThreadFactory() {
      @Override
      public Thread newThread(Runnable runnable) {
        Thread thread = backingThreadFactory.newThread(runnable);
        // TODO(b/139735208): Figure out what to do when the factory returns null.
        requireNonNull(thread);
        if (nameFormat != null) {

            return curlHelper.delete(path);
        default:
            break;
        }
        return null;
    }

    private HtmlResponse asListHtml(final Runnable runnable) {
        if (runnable != null) {
            runnable.run();
        }
        return asHtml(path_AdminEsreq_AdminEsreqJsp).useForm(UploadForm.class);
    }