@Test
  public void testBasic() throws Exception {
    CuratorFramework client =
        CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));
    try {
      client.start();

      final DistributedBarrier barrier = new DistributedBarrier(client, "/barrier");
      barrier.setBarrier();

      ExecutorService service = Executors.newSingleThreadExecutor();
      service.submit(
          new Callable<Object>() {
            @Override
            public Object call() throws Exception {
              Thread.sleep(1000);
              barrier.removeBarrier();
              return null;
            }
          });

      Assert.assertTrue(barrier.waitOnBarrier(10, TimeUnit.SECONDS));
    } finally {
      client.close();
    }
  }
  @Test
  public void testMultiClient() throws Exception {
    CuratorFramework client1 = null;
    CuratorFramework client2 = null;
    try {
      {
        CuratorFramework client =
            CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));
        try {
          client.start();
          DistributedBarrier barrier = new DistributedBarrier(client, "/barrier");
          barrier.setBarrier();
        } finally {
          CloseableUtils.closeQuietly(client);
        }
      }

      client1 = CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));
      client2 = CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));

      List<Future<Object>> futures = Lists.newArrayList();
      ExecutorService service = Executors.newCachedThreadPool();
      for (final CuratorFramework c : new CuratorFramework[] {client1, client2}) {
        Future<Object> future =
            service.submit(
                new Callable<Object>() {
                  @Override
                  public Object call() throws Exception {
                    c.start();
                    DistributedBarrier barrier = new DistributedBarrier(c, "/barrier");
                    barrier.waitOnBarrier(10, TimeUnit.MILLISECONDS);
                    return null;
                  }
                });
        futures.add(future);
      }

      Thread.sleep(1000);
      {
        CuratorFramework client =
            CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));
        try {
          client.start();
          DistributedBarrier barrier = new DistributedBarrier(client, "/barrier");
          barrier.removeBarrier();
        } finally {
          CloseableUtils.closeQuietly(client);
        }
      }

      for (Future<Object> f : futures) {
        f.get();
      }
    } finally {
      CloseableUtils.closeQuietly(client1);
      CloseableUtils.closeQuietly(client2);
    }
  }
  @Test
  public void testServerCrash() throws Exception {
    final int TIMEOUT = 1000;

    final CuratorFramework client =
        CuratorFrameworkFactory.builder()
            .connectString(server.getConnectString())
            .connectionTimeoutMs(TIMEOUT)
            .retryPolicy(new RetryOneTime(1))
            .build();
    try {
      client.start();

      final DistributedBarrier barrier = new DistributedBarrier(client, "/barrier");
      barrier.setBarrier();

      final ExecutorService service = Executors.newSingleThreadExecutor();
      Future<Object> future =
          service.submit(
              new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                  Thread.sleep(TIMEOUT / 2);
                  server.stop();
                  return null;
                }
              });

      barrier.waitOnBarrier(TIMEOUT * 2, TimeUnit.SECONDS);
      future.get();
      Assert.fail();
    } catch (KeeperException.ConnectionLossException expected) {
      // expected
    } finally {
      client.close();
    }
  }