package com.atlassian.vcache.internal.test;
   
   import com.atlassian.utt.concurrency.Barrier;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import java.util.concurrent.Callable;
   import java.util.concurrent.CompletableFuture;
   import java.util.concurrent.ExecutionException;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  
  public class TestUtils {
      private static final Logger log = LoggerFactory.getLogger(AbstractStableReadExternalCacheIT.class);
  
      private static final ExecutorService EXECUTOR_SERVICE = Executors.newCachedThreadPool();
  
      public static <T> CompletableFuture<T> runAndWaitForStart(final Callable<T> r) {
          final Barrier barrier = new Barrier();
          log.info("{}: About to submit()", Thread.currentThread().getName());
          final Future<T> result = EXECUTOR_SERVICE.submit(() -> {
              log.info("{}: About to signal()", Thread.currentThread().getName());
              barrier.signal();
              log.info("{}: resume after signal", Thread.currentThread().getName());
              return r.call();
          });
  
          log.info("{}: About to await()", Thread.currentThread().getName());
          barrier.await();
          log.info("{}: resume after await()", Thread.currentThread().getName());
  
          return CompletableFuture.supplyAsync(() -> {
              try {
                  return result.get();
              } catch (InterruptedException | ExecutionException e) {
                  throw new RuntimeException(e);
              }
          });
      }
  }