public void testSchedule() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

    Future<?> unused1 = testExecutor.schedule(() -> {}, 10, MINUTES);
    mock.assertLastMethodCalled("scheduleRunnable", 10, MINUTES);

    Future<?> unused2 = testExecutor.schedule(() -> null, 5, SECONDS);
    mock.assertLastMethodCalled("scheduleCallable", 5, SECONDS);
  }

    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);
    assertFalse(testExecutor.awaitTermination(10, MILLISECONDS));
    mock.assertLastMethodCalled("awaitTermination");
    assertFalse(testExecutor.isTerminated());
    mock.assertLastMethodCalled("isTerminated");
    assertFalse(testExecutor.isShutdown());
    mock.assertLastMethodCalled("isShutdown");

            }
        };

        NotificationHelper notificationHelper = new NotificationHelper() {
            // Mock send method
            public void send(final Object postcard) {
                // Mock implementation
            }
        };

        // Mock Postbox - no need to mock, the framework will handle it

        // Register components

    final Lock lock;

    LockingThread(Lock lock) {
      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

    final Lock lock;

    LockingThread(Lock lock) {
      this.lock = lock;
    }

    @Override
    public void run() {
      lock.lock();
      try {
        locked.countDown();
        finishLatch.await(1, MINUTES);
      } catch (InterruptedException e) {
        fail(e.toString());
      } finally {
        lock.unlock();
      }
    }

   *
   * Lock lockA = factory1.newReentrantLock(MyLockOrder.FIRST);
   * Lock lockB = factory1.newReentrantLock(MyLockOrder.FIRST);
   * Lock lockC = factory2.newReentrantLock(MyLockOrder.FIRST);
   *
   * lockA.lock();
   *
   * lockB.lock(); // will throw an IllegalStateException
   * lockC.lock(); // will throw an IllegalStateException
   *
   * lockA.lock(); // reentrant acquisition is okay
   * }

        .add(new Striped.SmallLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))

        .add(new Striped.SmallLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))

  }

  @AndroidIncompatible // Mocking ExecutorService is forbidden there. TODO(b/218700094): Don't mock.
  public void testGetExitingExecutorService_executorDelegatesToOriginal() {
    TestApplication application = new TestApplication();
    ThreadPoolExecutor executor = mock(ThreadPoolExecutor.class);
    ThreadFactory threadFactory = mock(ThreadFactory.class);
    when(executor.getThreadFactory()).thenReturn(threadFactory);

        CurlRequest req = new OpenOverrideCurlRequest(Curl.Method.GET, "http://dummy", u -> {
            TimeoutRecordingMockHttpURLConnection mock = new TimeoutRecordingMockHttpURLConnection(u);
            mockHolder[0] = mock;
            return mock;
        });
        req.timeout(3000, 5000);

        // ## Act ##
        try (CurlResponse response = req.execute()) {
            // ## Assert ##