java.util.concurrent.Semaphore

Here are the examples of the java api class java.util.concurrent.Semaphore taken from open source projects.

1. SemaphoreTest#testSem()

Project: async-event
File: SemaphoreTest.java
@Test
public void testSem() {
    int size = 3;
    Semaphore semaphore = new Semaphore(size);
    assertTrue(semaphore.tryAcquire(3));
    //1
    semaphore.release();
    try {
        assertTrue(!semaphore.tryAcquire(2, 1, TimeUnit.SECONDS));
    } catch (InterruptedException e) {
        fail();
    }
    semaphore.release();
    try {
        assertTrue(semaphore.tryAcquire(2, 1, TimeUnit.SECONDS));
    } catch (InterruptedException e) {
        fail();
    }
}

2. FLENewEpochTest#setUp()

Project: zookeeper
File: FLENewEpochTest.java
@Before
public void setUp() throws Exception {
    count = 3;
    peers = new HashMap<Long, QuorumServer>(count);
    threads = new ArrayList<LEThread>(count);
    tmpdir = new File[count];
    port = new int[count];
    round = new int[3];
    round[0] = 0;
    round[1] = 0;
    round[2] = 0;
    start0 = new Semaphore(0);
    finish0 = new Semaphore(0);
    finish3 = new Semaphore(0);
}

3. FlushTest#testSingleChannel()

Project: JGroups
File: FlushTest.java
public void testSingleChannel() throws Exception {
    Semaphore s = new Semaphore(1);
    FlushTestReceiver receivers[] = { new FlushTestReceiver("c1", s, 0, FlushTestReceiver.CONNECT_ONLY) };
    receivers[0].start();
    s.release(1);
    // Make sure everyone is in sync
    JChannel[] tmp = new JChannel[receivers.length];
    for (int i = 0; i < receivers.length; i++) tmp[i] = receivers[i].getChannel();
    Util.waitUntilAllChannelsHaveSameSize(10000, 1000, tmp);
    // Reacquire the semaphore tickets; when we have them all we know the threads are done
    s.tryAcquire(1, 10, TimeUnit.SECONDS);
    receivers[0].cleanup();
    Util.sleep(1000);
    checkEventStateTransferSequence(receivers[0]);
}

4. ZKTestBase#getClient()

Project: voltdb
File: ZKTestBase.java
protected ZooKeeper getClient(int site) throws Exception {
    final Semaphore permit = new Semaphore(0);
    int clientPort = m_siteIdToZKPort.get(site);
    ZooKeeper keeper = new ZooKeeper("127.0.0.1:" + Integer.toString(clientPort), 4000, new Watcher() {

        @Override
        public void process(WatchedEvent event) {
            if (event.getState() == KeeperState.SyncConnected) {
                permit.release();
            }
            System.out.println(event);
        }
    }, Sets.<Long>newHashSet());
    m_clients.add(keeper);
    permit.acquire();
    return keeper;
}

5. VideoStream#openCamera()

Project: spydroid-ipcamera
File: VideoStream.java
/**
	 * Opens the camera in a new Looper thread so that the preview callback is not called from the main thread
	 * If an exception is thrown in this Looper thread, we bring it back into the main thread.
	 * @throws RuntimeException Might happen if another app is already using the camera.
	 */
private void openCamera() throws RuntimeException {
    final Semaphore lock = new Semaphore(0);
    final RuntimeException[] exception = new RuntimeException[1];
    mCameraThread = new Thread(new Runnable() {

        @Override
        public void run() {
            Looper.prepare();
            mCameraLooper = Looper.myLooper();
            try {
                mCamera = Camera.open(mCameraId);
            } catch (RuntimeException e) {
                exception[0] = e;
            } finally {
                lock.release();
                Looper.loop();
            }
        }
    });
    mCameraThread.start();
    lock.acquireUninterruptibly();
    if (exception[0] != null)
        throw new CameraInUseException(exception[0].getMessage());
}

6. PtToPtIntentVirtualNetworkProviderTest#setUp()

Project: onos
File: PtToPtIntentVirtualNetworkProviderTest.java
@Before
public void setUp() {
    provider = new PtToPtIntentVirtualNetworkProvider();
    provider.providerRegistry = virtualNetworkRegistry;
    final CoreService mockCoreService = createMock(CoreService.class);
    provider.coreService = mockCoreService;
    expect(mockCoreService.registerApplication(PtToPtIntentVirtualNetworkProvider.PTPT_INTENT_APPID)).andReturn(APP_ID).anyTimes();
    replay(mockCoreService);
    Intent.unbindIdGenerator(idGenerator);
    Intent.bindIdGenerator(idGenerator);
    intentService.addListener(listener);
    provider.intentService = intentService;
    // Register a compiler and an installer both setup for success.
    intentExtensionService = intentService;
    intentExtensionService.registerCompiler(PointToPointIntent.class, compiler);
    provider.activate();
    created = new Semaphore(0, true);
    removed = new Semaphore(0, true);
}

7. CatTest#softCloseStdinAfterWrite()

Project: NuProcess
File: CatTest.java
@Test
public void softCloseStdinAfterWrite() throws Exception {
    Semaphore semaphore = new Semaphore(0);
    String text = "Hello world!";
    System.err.println("Starting test softCloseStdinAfterWrite()");
    Utf8DecodingListener processListener = new Utf8DecodingListener(semaphore, text, false);
    NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
    pb.start();
    semaphore.acquireUninterruptibly();
    Assert.assertEquals("Decoding mismatch", text, processListener.decodedStdout.toString());
    Assert.assertEquals("Exit code mismatch", 0, processListener.exitCode);
    Assert.assertFalse("Decoder stdin should not overflow", processListener.stdinOverflow);
    System.err.println("Completed test softCloseStdinAfterWrite()");
}

8. CatTest#changeCwd()

Project: NuProcess
File: CatTest.java
@Test
public void changeCwd() throws InterruptedException, IOException {
    Path javaCwd = Paths.get(System.getProperty("user.dir"));
    Path tmpPath = tmp.getRoot().toPath();
    System.err.println("Starting test changeCwd() (java cwd=" + javaCwd + ", tmp=" + tmpPath + ")");
    Assert.assertNotEquals("java cwd should not be tmp path before process", javaCwd.toRealPath(), tmpPath.toRealPath());
    String message = "Hello cwd-aware world\n";
    Files.write(tmpPath.resolve("foo.txt"), message.getBytes(Charset.forName("UTF-8")));
    final Semaphore semaphore = new Semaphore(0);
    Utf8DecodingListener processListener = new Utf8DecodingListener(semaphore, "", true);
    NuProcessBuilder pb = new NuProcessBuilder(processListener, command, "foo.txt");
    pb.setCwd(tmpPath);
    pb.start();
    semaphore.acquireUninterruptibly();
    Assert.assertEquals("Output mismatch", message, processListener.decodedStdout.toString());
    Assert.assertEquals("Exit code mismatch", 0, processListener.exitCode);
    javaCwd = Paths.get(System.getProperty("user.dir"));
    Assert.assertNotEquals("java cwd should not be tmp path after process", javaCwd.toRealPath(), tmpPath.toRealPath());
    System.err.println("Completed test changeCwd()");
}

9. CatTest#noExecutableFound()

Project: NuProcess
File: CatTest.java
@Test
public void noExecutableFound() {
    System.err.println("Starting test noExecutableFound()");
    final Semaphore semaphore = new Semaphore(0);
    final AtomicInteger exitCode = new AtomicInteger();
    NuProcessHandler processListener = new NuAbstractProcessHandler() {

        @Override
        public void onExit(int statusCode) {
            exitCode.set(statusCode);
            semaphore.release();
        }
    };
    NuProcessBuilder pb = new NuProcessBuilder(processListener, "/bin/zxczxc");
    NuProcess process = pb.start();
    semaphore.acquireUninterruptibly();
    Assert.assertFalse("Process incorrectly reported running", process.isRunning());
    Assert.assertEquals("Output did not matched expected result", Integer.MIN_VALUE, exitCode.get());
    System.err.println("Completed test noExecutableFound()");
}

10. CatTest#decodingLongUtf8Data()

Project: NuProcess
File: CatTest.java
@Test
public void decodingLongUtf8Data() throws Exception {
    Semaphore semaphore = new Semaphore(0);
    // We use 3 bytes to make sure at least one UTF-8 boundary goes across two byte buffers.
    String THREE_BYTE_UTF_8 = "?";
    StringBuilder unicodeTextWhichDoesNotFitInBuffer = new StringBuilder();
    for (int i = 0; i < NuProcess.BUFFER_CAPACITY + 1; i++) {
        unicodeTextWhichDoesNotFitInBuffer.append(THREE_BYTE_UTF_8);
    }
    System.err.println("Starting test decodingLongUtf8Data()");
    Utf8DecodingListener processListener = new Utf8DecodingListener(semaphore, unicodeTextWhichDoesNotFitInBuffer.toString(), true);
    NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
    pb.start();
    semaphore.acquireUninterruptibly();
    Assert.assertEquals("Decoding mismatch", unicodeTextWhichDoesNotFitInBuffer.toString(), processListener.decodedStdout.toString());
    Assert.assertEquals("Exit code mismatch", 0, processListener.exitCode);
    Assert.assertTrue("Decoder stdin should overflow", processListener.stdinOverflow);
    System.err.println("Completed test decodingLongUtf8Data()");
}

11. CatTest#decodingShortUtf8Data()

Project: NuProcess
File: CatTest.java
@Test
public void decodingShortUtf8Data() throws Exception {
    Semaphore semaphore = new Semaphore(0);
    String SHORT_UNICODE_TEXT = "Hello ?? world";
    System.err.println("Starting test decodingShortUtf8Data()");
    Utf8DecodingListener processListener = new Utf8DecodingListener(semaphore, SHORT_UNICODE_TEXT, true);
    NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
    pb.start();
    semaphore.acquireUninterruptibly();
    Assert.assertEquals("Decoding mismatch", SHORT_UNICODE_TEXT, processListener.decodedStdout.toString());
    Assert.assertEquals("Exit code mismatch", 0, processListener.exitCode);
    Assert.assertFalse("Decoder stdin should not overflow", processListener.stdinOverflow);
    System.err.println("Completed test decodingShortUtf8Data()");
}

12. VideoStream#openCamera()

Project: libstreaming
File: VideoStream.java
/**
	 * Opens the camera in a new Looper thread so that the preview callback is not called from the main thread
	 * If an exception is thrown in this Looper thread, we bring it back into the main thread.
	 * @throws RuntimeException Might happen if another app is already using the camera.
	 */
private void openCamera() throws RuntimeException {
    final Semaphore lock = new Semaphore(0);
    final RuntimeException[] exception = new RuntimeException[1];
    mCameraThread = new Thread(new Runnable() {

        @Override
        public void run() {
            Looper.prepare();
            mCameraLooper = Looper.myLooper();
            try {
                mCamera = Camera.open(mCameraId);
            } catch (RuntimeException e) {
                exception[0] = e;
            } finally {
                lock.release();
                Looper.loop();
            }
        }
    });
    mCameraThread.start();
    lock.acquireUninterruptibly();
    if (exception[0] != null)
        throw new CameraInUseException(exception[0].getMessage());
}

13. ClingRouter#deletePortMappingImpl()

Project: libresonic
File: ClingRouter.java
private void deletePortMappingImpl(Service connectionService, int port) throws Exception {
    final Semaphore gotReply = new Semaphore(0);
    upnpService.getControlPoint().execute(new PortMappingDelete(connectionService, createPortMapping(port)) {

        @Override
        public void success(ActionInvocation invocation) {
            gotReply.release();
        }

        @Override
        public void failure(ActionInvocation invocation, UpnpResponse response, String defaultMsg) {
            gotReply.release();
        }
    });
    gotReply.acquire();
}

14. ClingRouter#addPortMappingImpl()

Project: libresonic
File: ClingRouter.java
private void addPortMappingImpl(Service connectionService, int port) throws Exception {
    final Semaphore gotReply = new Semaphore(0);
    final AtomicReference<String> error = new AtomicReference<String>();
    upnpService.getControlPoint().execute(new PortMappingAdd(connectionService, createPortMapping(port)) {

        @Override
        public void success(ActionInvocation invocation) {
            gotReply.release();
        }

        @Override
        public void failure(ActionInvocation invocation, UpnpResponse response, String defaultMsg) {
            error.set(String.valueOf(response) + ": " + defaultMsg);
            gotReply.release();
        }
    });
    gotReply.acquire();
    if (error.get() != null) {
        throw new Exception(error.get());
    }
}

15. MetaDataCreateIndexService#createIndex()

Project: elassandra
File: MetaDataCreateIndexService.java
public void createIndex(final CreateIndexClusterStateUpdateRequest request, final ActionListener<ClusterStateUpdateResponse> listener) {
    // we lock here, and not within the cluster service callback since we don't want to
    // block the whole cluster state handling
    final Semaphore mdLock = metaDataService.indexMetaDataLock(request.index());
    // quick check to see if we can acquire a lock, otherwise spawn to a thread pool
    if (mdLock.tryAcquire()) {
        createIndex(request, listener, mdLock);
        return;
    }
    threadPool.executor(ThreadPool.Names.MANAGEMENT).execute(new ActionRunnable(listener) {

        @Override
        public void doRun() throws InterruptedException {
            if (!mdLock.tryAcquire(request.masterNodeTimeout().nanos(), TimeUnit.NANOSECONDS)) {
                listener.onFailure(new ProcessClusterEventTimeoutException(request.masterNodeTimeout(), "acquire index lock"));
                return;
            }
            createIndex(request, listener, mdLock);
        }
    });
}

16. EmbeddedActivator#refresh()

Project: bnd
File: EmbeddedActivator.java
/*
	 * Refresh the stopped bundles
	 */
void refresh(BundleContext context, List<Bundle> toStop) throws InterruptedException {
    Bundle bundle = context.getBundle(0);
    FrameworkWiring framework = bundle.adapt(FrameworkWiring.class);
    final Semaphore s = new Semaphore(0);
    framework.refreshBundles(toStop, new FrameworkListener() {

        @Override
        public void frameworkEvent(FrameworkEvent event) {
            s.release();
        }
    });
    s.tryAcquire(10, TimeUnit.SECONDS);
}

17. PackageFactoryTest#testCreatePackageIsolatedFromOuterErrors()

Project: bazel
File: PackageFactoryTest.java
@Test
public void testCreatePackageIsolatedFromOuterErrors() throws Exception {
    ExecutorService e = Executors.newCachedThreadPool();
    final Semaphore beforeError = new Semaphore(0);
    final Semaphore afterError = new Semaphore(0);
    Reporter reporter = new Reporter();
    ParsingTracker parser = new ParsingTracker(beforeError, afterError, reporter);
    final Logger log = Logger.getLogger(PackageFactory.class.getName());
    log.addHandler(parser);
    Level originalLevel = log.getLevel();
    log.setLevel(Level.FINE);
    e.execute(new ErrorReporter(reporter, beforeError, afterError));
    e.execute(parser);
    // wait for all to finish
    e.shutdown();
    assertTrue(e.awaitTermination(TestUtils.WAIT_TIMEOUT_MILLISECONDS, TimeUnit.MILLISECONDS));
    log.removeHandler(parser);
    log.setLevel(originalLevel);
    assertTrue(parser.hasParsed());
}

18. EmSupplierTest#asyncCleanLifeCycleTest()

Project: aries
File: EmSupplierTest.java
@Test
public void asyncCleanLifeCycleTest() throws InterruptedException {
    EntityManagerFactory emf = mockEmf();
    final Coordinator coordinator = new DummyCoordinator();
    final EMSupplierImpl emSupplier = new EMSupplierImpl("myunit", emf, coordinator);
    final Semaphore preCallSem = new Semaphore(0);
    Runnable command = new Runnable() {

        @Override
        public void run() {
            coordinator.begin("test", 0);
            preCallSem.release();
            coordinator.pop().end();
        }
    };
    Executors.newSingleThreadExecutor().execute(command);
    preCallSem.acquire();
    // EMs not closed when close is called but are closed before timeout 
    boolean clean = emSupplier.close();
    Assert.assertTrue("Shutdown should be clean", clean);
}

19. EmSupplierTest#asyncCleanLifeCycleTest()

Project: apache-aries
File: EmSupplierTest.java
@Test
public void asyncCleanLifeCycleTest() throws InterruptedException {
    EntityManagerFactory emf = mockEmf();
    final Coordinator coordinator = new DummyCoordinator();
    final EMSupplierImpl emSupplier = new EMSupplierImpl("myunit", emf, coordinator);
    final Semaphore preCallSem = new Semaphore(0);
    Runnable command = new Runnable() {

        @Override
        public void run() {
            coordinator.begin("test", 0);
            preCallSem.release();
            coordinator.pop().end();
        }
    };
    Executors.newSingleThreadExecutor().execute(command);
    preCallSem.acquire();
    // EMs not closed when close is called but are closed before timeout 
    boolean clean = emSupplier.close();
    Assert.assertTrue("Shutdown should be clean", clean);
}

20. RealDataTest#waitForGeoFireReady()

Project: geofire-java
File: RealDataTest.java
protected void waitForGeoFireReady(GeoFire geoFire) throws InterruptedException {
    final Semaphore semaphore = new Semaphore(0);
    geoFire.getDatabaseReference().addListenerForSingleValueEvent(new ValueEventListener() {

        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            semaphore.release();
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            Assert.fail("Firebase error: " + databaseError);
        }
    });
    Assert.assertTrue("Timeout occured!", semaphore.tryAcquire(TestHelpers.TIMEOUT_SECONDS, TimeUnit.SECONDS));
}

21. ImageLoader#init()

Project: GanWuMei
File: ImageLoader.java
/**
     * ???
     *
     * @param threadCount
     * @param type
     */
private void init(int threadCount, Type type) {
    initBackThread();
    // ?????????????
    int maxMemory = (int) Runtime.getRuntime().maxMemory();
    int cacheMemory = maxMemory / 8;
    mLruCache = new LruCache<String, Bitmap>(cacheMemory) {

        @Override
        protected int sizeOf(String key, Bitmap value) {
            return value.getRowBytes() * value.getHeight();
        }
    };
    // ?????
    mThreadPool = Executors.newFixedThreadPool(threadCount);
    mTaskQueue = new LinkedList<Runnable>();
    mType = type;
    mSemaphoreThreadPool = new Semaphore(threadCount);
}

22. InvokerStorage#newSemaphore()

Project: deltaspike
File: InvokerStorage.java
@Override
public Semaphore newSemaphore(final AnnotatedMethod<?> method, final String name, final boolean fair, final int permits) {
    Semaphore semaphore = semaphores.get(name);
    if (semaphore == null) {
        semaphore = new Semaphore(permits, fair);
        final Semaphore existing = semaphores.putIfAbsent(name, semaphore);
        if (existing != null) {
            semaphore = existing;
        }
    }
    return semaphore;
}

23. UiUtils#runOnUiThread()

Project: chromium_webview
File: UiUtils.java
/**
     * Runs the runnable on the UI thread.
     *
     * @param activity The activity on which the runnable must run.
     * @param runnable The runnable to run.
     */
public static void runOnUiThread(Activity activity, final Runnable runnable) {
    final Semaphore finishedSemaphore = new Semaphore(0);
    activity.runOnUiThread(new Runnable() {

        @Override
        public void run() {
            runnable.run();
            finishedSemaphore.release();
        }
    });
    try {
        Assert.assertTrue(finishedSemaphore.tryAcquire(1, WAIT_FOR_RESPONSE_MS, TimeUnit.MILLISECONDS));
    } catch (InterruptedException ignored) {
        Assert.assertTrue("Interrupted while waiting for main thread Runnable", false);
    }
}

24. MavenTaskExecutor#waitForEndAllTasks()

Project: che
File: MavenTaskExecutor.java
public void waitForEndAllTasks() {
    if (!isWorking) {
        return;
    }
    Semaphore semaphore = new Semaphore(1);
    try {
        semaphore.acquire();
        submitTask(semaphore::release);
        while (true) {
            if (!isWorking || semaphore.tryAcquire(1, TimeUnit.SECONDS)) {
                return;
            }
        }
    } catch (InterruptedException e) {
        LOG.debug(e.getMessage(), e);
    }
}

25. RepeatTestsGtasksSync#waitAndSync()

Project: astrid
File: RepeatTestsGtasksSync.java
@Override
protected void waitAndSync() {
    AndroidUtilities.sleepDeep(3000L);
    final Semaphore sema = new Semaphore(0);
    GtasksSyncV2Provider.getInstance().synchronizeActiveTasks(true, new SyncResultCallbackAdapter() {

        @Override
        public void finished() {
            sema.release();
        }
    });
    try {
        sema.acquire();
    } catch (InterruptedException e) {
        fail("Interrupted while waiting for sync to finish");
    }
    AndroidUtilities.sleepDeep(3000L);
    gtasksSyncService.waitUntilEmpty();
}

26. RepeatTestsActFmSync#waitAndSync()

Project: astrid
File: RepeatTestsActFmSync.java
@Override
protected void waitAndSync() {
    AndroidUtilities.sleepDeep(3000L);
    final Semaphore sema = new Semaphore(0);
    new ActFmSyncV2Provider().synchronizeActiveTasks(true, new SyncResultCallbackAdapter() {

        @Override
        public void finished() {
            sema.release();
        }
    });
    try {
        sema.acquire();
    } catch (InterruptedException e) {
        fail("Interrupted while waiting for sync to finish");
    }
    AndroidUtilities.sleepDeep(3000L);
}

27. GtasksNewSyncTest#whenInvokeSync()

Project: astrid
File: GtasksNewSyncTest.java
//Perform a synchronization
private void whenInvokeSync() {
    final Semaphore sema = new Semaphore(0);
    GtasksSyncV2Provider.getInstance().synchronizeActiveTasks(true, new SyncResultCallbackAdapter() {

        @Override
        public void finished() {
            sema.release();
        }
    });
    try {
        sema.acquire();
    } catch (InterruptedException e) {
        fail("Interrupted while waiting for sync to finish");
    }
}

28. RestCallLimiter#tryAcquireAndRun()

Project: zanata-server
File: RestCallLimiter.java
/**
     * This method is potentially blocking on available active permits. It may
     * throw an exception if it takes too long to obtain one of the semaphores.
     * It may immediately return false if there is not enough concurrent
     * permits.
     *
     * @param taskAfterAcquire
     *            task to perform after acquire
     */
public boolean tryAcquireAndRun(RunnableEx taskAfterAcquire) throws Exception {
    // hang on to the semaphore, so that we can be certain of
    // releasing the same one we acquired
    final Semaphore concSem = maxConcurrentSemaphore;
    boolean gotConcurrentPermit = concSem.tryAcquire();
    if (gotConcurrentPermit) {
        // if acquired, immediately enter try finally (release)
        try {
            log.debug("acquired [concurrent] permit");
            if (!acquireActivePermit(taskAfterAcquire)) {
                throw new RuntimeException("Couldn't get an [active] permit before timeout");
            }
        } finally {
            concSem.release();
            log.debug("released [concurrent] semaphore");
        }
    } else {
        log.debug("failed to acquire [concurrent] permit");
    }
    return gotConcurrentPermit;
}

29. ZKUtil#getClient()

Project: voltdb
File: ZKUtil.java
public static final ZooKeeper getClient(String zkAddress, int timeout, Set<Long> verbotenThreads) throws Exception {
    final Semaphore zkConnect = new Semaphore(0);
    ZooKeeper zk = new ZooKeeper(zkAddress, 2000, new Watcher() {

        @Override
        public void process(WatchedEvent event) {
            if (event.getState() == KeeperState.SyncConnected) {
                zkConnect.release();
            }
        }
    }, verbotenThreads);
    if (!zkConnect.tryAcquire(timeout, TimeUnit.MILLISECONDS)) {
        return null;
    }
    return zk;
}

30. ServiceAssemblyImpl#startShutdownMonitorThread()

Project: servicemix4-nmr
File: ServiceAssemblyImpl.java
/*
     * Start the shutdown monitor thread and return a semaphore to notify the thread of a clean shutdown
     */
private Semaphore startShutdownMonitorThread() {
    final Semaphore semaphore = new Semaphore(0);
    Thread thread = new Thread(getName() + " - Shutdown Monitor Thread") {

        @Override
        public void run() {
            try {
                LOGGER.debug("Waiting for " + shutdownTimeout + " milliseconds to a clean shutdown of SA " + ServiceAssemblyImpl.this.getName());
                if (!semaphore.tryAcquire(shutdownTimeout, TimeUnit.MILLISECONDS)) {
                    LOGGER.warn("Unable to do a clean shutdown of SA " + ServiceAssemblyImpl.this.getName() + ", canceling all sync exchanges");
                    listener.cancelPendingSyncExchanges(ServiceAssemblyImpl.this);
                }
            } catch (InterruptedException e) {
            }
        }
    };
    thread.setDaemon(true);
    thread.start();
    return semaphore;
}

31. AsyncServer#run()

Project: RemoteDroid
File: AsyncServer.java
public void run(final Runnable runnable) {
    if (Thread.currentThread() == mAffinity) {
        post(runnable);
        lockAndRunQueue(this, mQueue);
        return;
    }
    final Semaphore semaphore = new Semaphore(0);
    post(new Runnable() {

        @Override
        public void run() {
            runnable.run();
            semaphore.release();
        }
    });
    try {
        semaphore.acquire();
    } catch (InterruptedException e) {
        Log.e(LOGTAG, "run", e);
    }
}

32. ReactIntegrationTestCase#initializeJavaModule()

Project: react-native
File: ReactIntegrationTestCase.java
protected static void initializeJavaModule(final BaseJavaModule javaModule) {
    final Semaphore semaphore = new Semaphore(0);
    UiThreadUtil.runOnUiThread(new Runnable() {

        @Override
        public void run() {
            javaModule.initialize();
            if (javaModule instanceof LifecycleEventListener) {
                ((LifecycleEventListener) javaModule).onHostResume();
            }
            semaphore.release();
        }
    });
    try {
        SoftAssertions.assertCondition(semaphore.tryAcquire(5000, TimeUnit.MILLISECONDS), "Timed out initializing timing module");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

33. ParsePushTest#testUnsubscribeInBackgroundWithCallbackFail()

Project: Parse-SDK-Android
File: ParsePushTest.java
@Test
public void testUnsubscribeInBackgroundWithCallbackFail() throws Exception {
    ParsePushChannelsController controller = mock(ParsePushChannelsController.class);
    final ParseException exception = new ParseException(ParseException.OTHER_CAUSE, "error");
    when(controller.unsubscribeInBackground(anyString())).thenReturn(Task.<Void>forError(exception));
    ParseCorePlugins.getInstance().registerPushChannelsController(controller);
    ParsePush push = new ParsePush();
    final Semaphore done = new Semaphore(0);
    final Capture<Exception> exceptionCapture = new Capture<>();
    push.unsubscribeInBackground("test", new SaveCallback() {

        @Override
        public void done(ParseException e) {
            exceptionCapture.set(e);
            done.release();
        }
    });
    assertSame(exception, exceptionCapture.get());
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).unsubscribeInBackground("test");
}

34. ParsePushTest#testUnsubscribeInBackgroundWithCallbackSuccess()

Project: Parse-SDK-Android
File: ParsePushTest.java
@Test
public void testUnsubscribeInBackgroundWithCallbackSuccess() throws Exception {
    final ParsePushChannelsController controller = mock(ParsePushChannelsController.class);
    when(controller.unsubscribeInBackground(anyString())).thenReturn(Task.<Void>forResult(null));
    ParseCorePlugins.getInstance().registerPushChannelsController(controller);
    ParsePush push = new ParsePush();
    final Semaphore done = new Semaphore(0);
    final Capture<Exception> exceptionCapture = new Capture<>();
    push.unsubscribeInBackground("test", new SaveCallback() {

        @Override
        public void done(ParseException e) {
            exceptionCapture.set(e);
            done.release();
        }
    });
    assertNull(exceptionCapture.get());
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).unsubscribeInBackground("test");
}

35. ParsePushTest#testSubscribeInBackgroundWithCallbackFail()

Project: Parse-SDK-Android
File: ParsePushTest.java
@Test
public void testSubscribeInBackgroundWithCallbackFail() throws Exception {
    ParsePushChannelsController controller = mock(ParsePushChannelsController.class);
    final ParseException exception = new ParseException(ParseException.OTHER_CAUSE, "error");
    when(controller.subscribeInBackground(anyString())).thenReturn(Task.<Void>forError(exception));
    ParseCorePlugins.getInstance().registerPushChannelsController(controller);
    ParsePush push = new ParsePush();
    final Semaphore done = new Semaphore(0);
    final Capture<Exception> exceptionCapture = new Capture<>();
    push.subscribeInBackground("test", new SaveCallback() {

        @Override
        public void done(ParseException e) {
            exceptionCapture.set(e);
            done.release();
        }
    });
    assertSame(exception, exceptionCapture.get());
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).subscribeInBackground("test");
}

36. ParsePushTest#testSubscribeInBackgroundWithCallbackSuccess()

Project: Parse-SDK-Android
File: ParsePushTest.java
@Test
public void testSubscribeInBackgroundWithCallbackSuccess() throws Exception {
    final ParsePushChannelsController controller = mock(ParsePushChannelsController.class);
    when(controller.subscribeInBackground(anyString())).thenReturn(Task.<Void>forResult(null));
    ParseCorePlugins.getInstance().registerPushChannelsController(controller);
    ParsePush push = new ParsePush();
    final Semaphore done = new Semaphore(0);
    final Capture<Exception> exceptionCapture = new Capture<>();
    push.subscribeInBackground("test", new SaveCallback() {

        @Override
        public void done(ParseException e) {
            exceptionCapture.set(e);
            done.release();
        }
    });
    assertNull(exceptionCapture.get());
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).subscribeInBackground("test");
}

37. ParseConfigTest#testGetInBackgroundWithCallbackFail()

Project: Parse-SDK-Android
File: ParseConfigTest.java
@Test
public void testGetInBackgroundWithCallbackFail() throws Exception {
    ParseException exception = new ParseException(ParseException.CONNECTION_FAILED, "error");
    ParseConfigController controller = mockParseConfigControllerWithException(exception);
    ParseCorePlugins.getInstance().registerConfigController(controller);
    final Semaphore done = new Semaphore(0);
    ParseConfig.getInBackground(new ConfigCallback() {

        @Override
        public void done(ParseConfig config, ParseException e) {
            assertEquals(ParseException.CONNECTION_FAILED, e.getCode());
            assertEquals("error", e.getMessage());
            done.release();
        }
    });
    // Make sure the callback is called
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).getAsync(anyString());
}

38. ParseConfigTest#testGetInBackgroundWithCallbackSuccess()

Project: Parse-SDK-Android
File: ParseConfigTest.java
@Test
public void testGetInBackgroundWithCallbackSuccess() throws Exception {
    final Map<String, Object> params = new HashMap<>();
    params.put("string", "value");
    ParseConfig config = new ParseConfig(params);
    ParseConfigController controller = mockParseConfigControllerWithResponse(config);
    ParseCorePlugins.getInstance().registerConfigController(controller);
    final Semaphore done = new Semaphore(0);
    ParseConfig.getInBackground(new ConfigCallback() {

        @Override
        public void done(ParseConfig config, ParseException e) {
            assertEquals(1, config.params.size());
            assertEquals("value", config.params.get("string"));
            done.release();
        }
    });
    // Make sure the callback is called
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).getAsync(anyString());
}

39. ParseCloudTest#testCallFunctionNormalCallback()

Project: Parse-SDK-Android
File: ParseCloudTest.java
@Test
public void testCallFunctionNormalCallback() throws Exception {
    ParseCloudCodeController controller = mockParseCloudCodeControllerWithResponse("result");
    ParseCorePlugins.getInstance().registerCloudCodeController(controller);
    Map<String, Object> parameters = new HashMap<>();
    parameters.put("key1", Arrays.asList(1, 2, 3));
    parameters.put("key2", "value1");
    final Semaphore done = new Semaphore(0);
    ParseCloud.callFunctionInBackground("name", parameters, new FunctionCallback<Object>() {

        @Override
        public void done(Object result, ParseException e) {
            assertNull(e);
            assertThat(result, instanceOf(String.class));
            assertEquals("result", result);
            done.release();
        }
    });
    // Make sure the callback is called
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).callFunctionInBackground(eq("name"), eq(parameters), isNull(String.class));
}

40. ParseAnalyticsTest#testTrackAppOpenedInBackgroundNormalCallback()

Project: Parse-SDK-Android
File: ParseAnalyticsTest.java
@Test
public void testTrackAppOpenedInBackgroundNormalCallback() throws Exception {
    Intent intent = makeIntentWithParseData("test");
    final Semaphore done = new Semaphore(0);
    ParseAnalytics.trackAppOpenedInBackground(intent, new SaveCallback() {

        @Override
        public void done(ParseException e) {
            assertNull(e);
            done.release();
        }
    });
    // Make sure the callback is called
    assertTrue(done.tryAcquire(1, 10, TimeUnit.SECONDS));
    verify(controller, times(1)).trackAppOpenedInBackground(eq("test"), isNull(String.class));
}

41. SemaphoreTest#testReleaseAcquireSameThread()

Project: openjdk
File: SemaphoreTest.java
public void testReleaseAcquireSameThread(boolean fair, final AcquireMethod acquirer) {
    Semaphore s = new Semaphore(1, fair);
    for (int i = 1; i < 6; i++) {
        s.release(i);
        assertEquals(1 + i, s.availablePermits());
        try {
            acquirer.acquire(s, i);
        } catch (InterruptedException e) {
            threadUnexpectedException(e);
        }
        assertEquals(1, s.availablePermits());
    }
}

42. CleanerTest#setupSoftSubclassException()

Project: openjdk
File: CleanerTest.java
/**
     * Create a CleanableCase for a SoftReference.
     * @param cleaner the cleaner to use
     * @param obj an object or null to create a new Object
     * @return a new CleanableCase preset with the object, cleanup, and semaphore
     */
static CleanableCase setupSoftSubclassException(Cleaner cleaner, Object obj) {
    if (obj == null) {
        obj = new Object();
    }
    Semaphore s1 = new Semaphore(0);
    Cleaner.Cleanable c1 = new SoftCleanable<Object>(obj, cleaner) {

        protected void performCleanup() {
            s1.release();
            throw new RuntimeException("Exception thrown to cleaner thread");
        }
    };
    return new CleanableCase(new SoftReference<>(obj, null), c1, s1, true);
}

43. CleanerTest#setupWeakSubclassException()

Project: openjdk
File: CleanerTest.java
/**
     * Create a CleanableCase for a WeakReference.
     * @param cleaner the cleaner to use
     * @param obj an object or null to create a new Object
     * @return a new CleanableCase preset with the object, cleanup, and semaphore
     */
static CleanableCase setupWeakSubclassException(Cleaner cleaner, Object obj) {
    if (obj == null) {
        obj = new Object();
    }
    Semaphore s1 = new Semaphore(0);
    Cleaner.Cleanable c1 = new WeakCleanable<Object>(obj, cleaner) {

        protected void performCleanup() {
            s1.release();
            throw new RuntimeException("Exception thrown to cleaner thread");
        }
    };
    return new CleanableCase(new WeakReference<>(obj, null), c1, s1, true);
}

44. CleanerTest#setupPhantomSubclassException()

Project: openjdk
File: CleanerTest.java
/**
     * Create a CleanableCase for a PhantomReference.
     * @param cleaner the cleaner to use
     * @param obj an object or null to create a new Object
     * @return a new CleanableCase preset with the object, cleanup, and semaphore
     */
static CleanableCase setupPhantomSubclassException(Cleaner cleaner, Object obj) {
    if (obj == null) {
        obj = new Object();
    }
    Semaphore s1 = new Semaphore(0);
    Cleaner.Cleanable c1 = new PhantomCleanable<Object>(obj, cleaner) {

        protected void performCleanup() {
            s1.release();
            throw new RuntimeException("Exception thrown to cleaner thread");
        }
    };
    return new CleanableCase(new PhantomReference<>(obj, null), c1, s1, true);
}

45. CleanerTest#setupSoftSubclass()

Project: openjdk
File: CleanerTest.java
/**
     * Create a CleanableCase for a SoftReference.
     * @param cleaner the cleaner to use
     * @param obj an object or null to create a new Object
     * @return a new CleanableCase preset with the object, cleanup, and semaphore
     */
static CleanableCase setupSoftSubclass(Cleaner cleaner, Object obj) {
    if (obj == null) {
        obj = new Object();
    }
    Semaphore s1 = new Semaphore(0);
    Cleaner.Cleanable c1 = new SoftCleanable<Object>(obj, cleaner) {

        protected void performCleanup() {
            s1.release();
        }
    };
    return new CleanableCase(new SoftReference<>(obj, null), c1, s1);
}

46. CleanerTest#setupWeakSubclass()

Project: openjdk
File: CleanerTest.java
/**
     * Create a CleanableCase for a WeakReference.
     * @param cleaner the cleaner to use
     * @param obj an object or null to create a new Object
     * @return a new CleanableCase preset with the object, cleanup, and semaphore
     */
static CleanableCase setupWeakSubclass(Cleaner cleaner, Object obj) {
    if (obj == null) {
        obj = new Object();
    }
    Semaphore s1 = new Semaphore(0);
    Cleaner.Cleanable c1 = new WeakCleanable<Object>(obj, cleaner) {

        protected void performCleanup() {
            s1.release();
        }
    };
    return new CleanableCase(new WeakReference<>(obj, null), c1, s1);
}

47. CleanerTest#setupPhantomSubclass()

Project: openjdk
File: CleanerTest.java
/**
     * Create a CleanableCase for a PhantomReference.
     * @param cleaner the cleaner to use
     * @param obj an object or null to create a new Object
     * @return a new CleanableCase preset with the object, cleanup, and semaphore
     */
static CleanableCase setupPhantomSubclass(Cleaner cleaner, Object obj) {
    if (obj == null) {
        obj = new Object();
    }
    Semaphore s1 = new Semaphore(0);
    Cleaner.Cleanable c1 = new PhantomCleanable<Object>(obj, cleaner) {

        protected void performCleanup() {
            s1.release();
        }
    };
    return new CleanableCase(new PhantomReference<>(obj, null), c1, s1);
}

48. DistributedConsensusLoadTest#startTest()

Project: onos
File: DistributedConsensusLoadTest.java
private void startTest() {
    stopped.set(false);
    RateLimiter limiter = RateLimiter.create(rate);
    Semaphore s = new Semaphore(100);
    while (!stopped.get()) {
        limiter.acquire();
        s.acquireUninterruptibly();
        counters.get(RandomUtils.nextInt(TOTAL_COUNTERS)).incrementAndGet().whenComplete(( r,  e) -> {
            s.release();
            if (e == null) {
                increments.incrementAndGet();
            }
        });
    }
}

49. JUConcurrentTests#semaphore()

Project: java-thread-sanitizer
File: JUConcurrentTests.java
@RaceTest(expectRace = false, description = "Semaphore")
public void semaphore() {
    final Semaphore semaphore = new Semaphore(0);
    new ThreadRunner(2) {

        public void thread1() {
            longSleep();
            sharedVar = 1;
            semaphore.release();
        }

        public void thread2() {
            try {
                semaphore.acquire();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            sharedVar = 2;
        }
    };
}

50. AsyncIndexUpdateTest#branchBaseOnCheckpoint()

Project: jackrabbit-oak
File: AsyncIndexUpdateTest.java
// OAK-1749
@Test
public void branchBaseOnCheckpoint() throws Exception {
    final Semaphore retrieve = new Semaphore(1);
    final Semaphore checkpoint = new Semaphore(0);
    NodeStore store = new MemoryNodeStore() {

        @CheckForNull
        @Override
        public NodeState retrieve(@Nonnull String checkpoint) {
            retrieve.acquireUninterruptibly();
            try {
                return super.retrieve(checkpoint);
            } finally {
                retrieve.release();
            }
        }

        @Nonnull
        @Override
        public String checkpoint(long lifetime, @Nonnull Map<String, String> properties) {
            try {
                return super.checkpoint(lifetime, properties);
            } finally {
                checkpoint.release();
            }
        }
    };
    IndexEditorProvider provider = new PropertyIndexEditorProvider();
    NodeBuilder builder = store.getRoot().builder();
    createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "foo", false, ImmutableSet.of("foo"), null, TYPE, Collections.singletonMap(ASYNC_PROPERTY_NAME, "async"));
    builder.child("test").setProperty("foo", "a");
    builder.child("child");
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    final AsyncIndexUpdate async = new AsyncIndexUpdate("async", store, provider);
    async.run();
    builder = store.getRoot().builder();
    builder.child("test").setProperty("foo", "b");
    builder.child("child").setProperty("prop", "value");
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            async.run();
        }
    });
    // drain checkpoint permits
    checkpoint.acquireUninterruptibly(checkpoint.availablePermits());
    // block NodeStore.retrieve()
    retrieve.acquireUninterruptibly();
    t.start();
    // wait until async update called checkpoint
    retrieve.release();
    checkpoint.acquireUninterruptibly();
    builder = store.getRoot().builder();
    builder.child("child").remove();
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    // allow async update to proceed with NodeStore.retrieve()
    retrieve.release();
    t.join();
    assertFalse(store.getRoot().hasChildNode("child"));
}

51. BackupServiceIntegrationTest#shouldReturnIfBackupIsInProgress()

Project: gocd
File: BackupServiceIntegrationTest.java
@Test
public void shouldReturnIfBackupIsInProgress() throws SQLException, InterruptedException {
    final Semaphore waitForBackupToBegin = new Semaphore(1);
    final Semaphore waitForAssertion_whichHasToHappen_whileBackupIsRunning = new Semaphore(1);
    Database databaseStrategyMock = mock(Database.class);
    doAnswer(new Answer<Object>() {

        @Override
        public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
            waitForBackupToBegin.release();
            waitForAssertion_whichHasToHappen_whileBackupIsRunning.acquire();
            return null;
        }
    }).when(databaseStrategyMock).backup(any(File.class));
    final BackupService backupService = new BackupService(dataSource, artifactsDirHolder, goConfigService, new TimeProvider(), backupInfoRepository, systemEnvironment, serverVersion, configRepository, databaseStrategyMock);
    waitForBackupToBegin.acquire();
    Thread thd = new Thread(new Runnable() {

        public void run() {
            backupService.startBackup(admin, new HttpLocalizedOperationResult());
        }
    });
    thd.start();
    waitForAssertion_whichHasToHappen_whileBackupIsRunning.acquire();
    waitForBackupToBegin.acquire();
    assertThat(backupService.isBackingUp(), is(true));
    waitForAssertion_whichHasToHappen_whileBackupIsRunning.release();
    thd.join();
}

52. BackupServiceIntegrationTest#shouldReturnBackupStartedBy()

Project: gocd
File: BackupServiceIntegrationTest.java
@Test
public void shouldReturnBackupStartedBy() throws InterruptedException {
    assertThat(backupService.backupStartedBy(), is(nullValue()));
    final Semaphore waitForBackupToStart = new Semaphore(1);
    final Semaphore waitForAssertionToCompleteWhileBackupIsOn = new Semaphore(1);
    final HttpLocalizedOperationResult result = new HttpLocalizedOperationResult() {

        @Override
        public void setMessage(Localizable message) {
            waitForBackupToStart.release();
            super.setMessage(message);
            try {
                waitForAssertionToCompleteWhileBackupIsOn.acquire();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    };
    waitForAssertionToCompleteWhileBackupIsOn.acquire();
    waitForBackupToStart.acquire();
    Thread backupThd = new Thread(new Runnable() {

        public void run() {
            backupService.startBackup(admin, result);
        }
    });
    backupThd.start();
    waitForBackupToStart.acquire();
    String backupStartedBy = backupService.backupStartedBy();
    assertThat(ReflectionUtil.getField(backupService, "backupStartedBy"), is((Object) backupStartedBy));
    waitForAssertionToCompleteWhileBackupIsOn.release();
    backupThd.join();
}

53. BackupServiceIntegrationTest#shouldReturnBackupRunningSinceValue_inISO8601_format()

Project: gocd
File: BackupServiceIntegrationTest.java
@Test
public void shouldReturnBackupRunningSinceValue_inISO8601_format() throws InterruptedException {
    assertThat(backupService.backupRunningSinceISO8601(), is(nullValue()));
    final Semaphore waitForBackupToStart = new Semaphore(1);
    final Semaphore waitForAssertionToCompleteWhileBackupIsOn = new Semaphore(1);
    final HttpLocalizedOperationResult result = new HttpLocalizedOperationResult() {

        @Override
        public void setMessage(Localizable message) {
            waitForBackupToStart.release();
            super.setMessage(message);
            try {
                waitForAssertionToCompleteWhileBackupIsOn.acquire();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    };
    waitForAssertionToCompleteWhileBackupIsOn.acquire();
    waitForBackupToStart.acquire();
    Thread backupThd = new Thread(new Runnable() {

        public void run() {
            backupService.startBackup(admin, result);
        }
    });
    backupThd.start();
    waitForBackupToStart.acquire();
    String backupStartedTimeString = backupService.backupRunningSinceISO8601();
    DateTimeFormatter dateTimeFormatter = ISODateTimeFormat.dateTime();
    DateTime dateTime = dateTimeFormatter.parseDateTime(backupStartedTimeString);
    assertThat(ReflectionUtil.getField(backupService, "backupRunningSince"), is((Object) dateTime));
    waitForAssertionToCompleteWhileBackupIsOn.release();
    backupThd.join();
}

54. BrokerBenchmark#testPerformance()

Project: activemq-artemis
File: BrokerBenchmark.java
public void testPerformance() throws Exception {
    LOG.info("Running Benchmark for destination=" + destination + ", producers=" + prodcuerCount + ", consumers=" + consumerCount + ", deliveryMode=" + deliveryMode);
    final int consumeCount = destination.isTopic() ? consumerCount * produceCount : produceCount;
    final Semaphore consumersStarted = new Semaphore(1 - consumerCount);
    final Semaphore producersFinished = new Semaphore(1 - prodcuerCount);
    final Semaphore consumersFinished = new Semaphore(1 - consumerCount);
    final ProgressPrinter printer = new ProgressPrinter(produceCount + consumeCount, 10);
    // Start a producer and consumer
    profilerPause("Benchmark ready.  Start profiler ");
    long start = System.currentTimeMillis();
    final AtomicInteger receiveCounter = new AtomicInteger(0);
    for (int i = 0; i < consumerCount; i++) {
        new Thread() {

            @Override
            public void run() {
                try {
                    // Consume the messages
                    StubConnection connection = new StubConnection(broker);
                    ConnectionInfo connectionInfo = createConnectionInfo();
                    connection.send(connectionInfo);
                    SessionInfo sessionInfo = createSessionInfo(connectionInfo);
                    ConsumerInfo consumerInfo = createConsumerInfo(sessionInfo, destination);
                    consumerInfo.setPrefetchSize(1000);
                    connection.send(sessionInfo);
                    connection.send(consumerInfo);
                    consumersStarted.release();
                    while (receiveCounter.get() < consumeCount) {
                        int counter = 0;
                        // Get a least 1 message.
                        Message msg = receiveMessage(connection, 2000);
                        if (msg != null) {
                            printer.increment();
                            receiveCounter.incrementAndGet();
                            counter++;
                            // Try to piggy back a few extra message acks if
                            // they are ready.
                            Message extra = null;
                            while ((extra = receiveMessage(connection, 0)) != null) {
                                msg = extra;
                                printer.increment();
                                receiveCounter.incrementAndGet();
                                counter++;
                            }
                        }
                        if (msg != null) {
                            connection.send(createAck(consumerInfo, msg, counter, MessageAck.STANDARD_ACK_TYPE));
                        } else if (receiveCounter.get() < consumeCount) {
                            LOG.info("Consumer stall, waiting for message #" + receiveCounter.get() + 1);
                        }
                    }
                    connection.send(closeConsumerInfo(consumerInfo));
                } catch (Throwable e) {
                    e.printStackTrace();
                } finally {
                    consumersFinished.release();
                }
            }
        }.start();
    }
    // Make sure that the consumers are started first to avoid sending
    // messages
    // before a topic is subscribed so that those messages are not missed.
    consumersStarted.acquire();
    // Send the messages in an async thread.
    for (int i = 0; i < prodcuerCount; i++) {
        new Thread() {

            @Override
            public void run() {
                try {
                    StubConnection connection = new StubConnection(broker);
                    ConnectionInfo connectionInfo = createConnectionInfo();
                    connection.send(connectionInfo);
                    SessionInfo sessionInfo = createSessionInfo(connectionInfo);
                    ProducerInfo producerInfo = createProducerInfo(sessionInfo);
                    connection.send(sessionInfo);
                    connection.send(producerInfo);
                    for (int i = 0; i < produceCount / prodcuerCount; i++) {
                        Message message = createMessage(producerInfo, destination);
                        message.setPersistent(deliveryMode);
                        message.setResponseRequired(false);
                        connection.send(message);
                        printer.increment();
                    }
                } catch (Throwable e) {
                    e.printStackTrace();
                } finally {
                    producersFinished.release();
                }
            }
        }.start();
    }
    producersFinished.acquire();
    long end1 = System.currentTimeMillis();
    consumersFinished.acquire();
    long end2 = System.currentTimeMillis();
    LOG.info("Results for destination=" + destination + ", producers=" + prodcuerCount + ", consumers=" + consumerCount + ", deliveryMode=" + deliveryMode);
    LOG.info("Produced at messages/sec: " + (produceCount * 1000.0 / (end1 - start)));
    LOG.info("Consumed at messages/sec: " + (consumeCount * 1000.0 / (end2 - start)));
    profilerPause("Benchmark done.  Stop profiler ");
}

55. TestSlowViewStateManager#testClusterSyncService_withConcurrency()

Project: sling
File: TestSlowViewStateManager.java
//TODO test takes env 10sec
@Category(Slow.class)
@Test
public void testClusterSyncService_withConcurrency() throws Exception {
    final org.apache.log4j.Logger commonsLogger = LogManager.getRootLogger().getLogger("org.apache.sling.discovery.commons.providers");
    final org.apache.log4j.Level logLevel = commonsLogger.getLevel();
    // change here to DEBUG in case of issues with this test
    commonsLogger.setLevel(Level.INFO);
    final Semaphore serviceSemaphore = new Semaphore(0);
    final Semaphore testSemaphore = new Semaphore(0);
    final ReentrantLock lock = new ReentrantLock();
    final ClusterSyncServiceWithSemaphore cs = new ClusterSyncServiceWithSemaphore(lock, serviceSemaphore);
    mgr = new ViewStateManagerImpl(lock, cs);
    final DummyListener listener = new DummyListener();
    mgr.bind(listener);
    TestHelper.assertNoEvents(listener);
    mgr.handleActivated();
    TestHelper.assertNoEvents(listener);
    final String slingId1 = UUID.randomUUID().toString();
    final String slingId2 = UUID.randomUUID().toString();
    final String slingId3 = UUID.randomUUID().toString();
    final String clusterId = UUID.randomUUID().toString();
    final DefaultClusterView cluster = new DefaultClusterView(clusterId);
    final DummyTopologyView view1 = new DummyTopologyView().addInstance(slingId1, cluster, true, true).addInstance(slingId2, cluster, false, false).addInstance(slingId3, cluster, false, false);
    final DummyTopologyView view2 = DummyTopologyView.clone(view1).removeInstance(slingId2);
    final DummyTopologyView view3 = DummyTopologyView.clone(view1).removeInstance(slingId2).removeInstance(slingId3);
    async(new Runnable() {

        public void run() {
            mgr.handleNewView(view1);
        }
    });
    Thread.sleep(1000);
    TestHelper.assertNoEvents(listener);
    assertEquals("should have one thread now waiting", 1, serviceSemaphore.getQueueLength());
    // release the first one only
    serviceSemaphore.release(1);
    Thread.sleep(1000);
    assertEvents(listener, EventHelper.newInitEvent(view1));
    mgr.handleChanging();
    assertEquals(0, mgr.waitForAsyncEvents(500));
    assertEvents(listener, EventHelper.newChangingEvent(view1));
    async(new Runnable() {

        public void run() {
            mgr.handleNewView(view2);
        }
    });
    logger.debug("run: waiting 1sec");
    Thread.sleep(1000);
    logger.debug("run: asserting no events");
    TestHelper.assertNoEvents(listener);
    assertEquals("should have one thread now waiting", 1, serviceSemaphore.getQueueLength());
    assertFalse("should not be locked", lock.isLocked());
    logger.debug("run: issuing a second event");
    // before releasing, issue another event, lets do a combination of changing/changed
    async(new Runnable() {

        public void run() {
            logger.debug("run2: calling handleChanging...");
            mgr.handleChanging();
            try {
                logger.debug("run2: done with handleChanging, acquiring testSemaphore...");
                testSemaphore.acquire();
                logger.debug("run2: calling handleNewView...");
                mgr.handleNewView(view3);
                logger.debug("run2: done with handleNewView...");
            } catch (InterruptedException e) {
                logger.error("interrupted: " + e, e);
            }
        }
    });
    logger.debug("run: waiting 1sec");
    Thread.sleep(1000);
    int remainingAsyncEvents = mgr.waitForAsyncEvents(2000);
    logger.info("run: result of waitForAsyncEvent is: " + remainingAsyncEvents);
    assertEquals("should have one thread now waiting", 1, serviceSemaphore.getQueueLength());
    assertEquals("should be acquiring (by thread2)", 1, testSemaphore.getQueueLength());
    // releasing the testSemaphore
    testSemaphore.release();
    logger.debug("run: waiting 1sec");
    Thread.sleep(1000);
    assertEquals("should have two async events now in the queue or being sent", 2, mgr.waitForAsyncEvents(500));
    assertEquals("but should only have 1 thread actually sitting on the semaphore waiting", 1, serviceSemaphore.getQueueLength());
    logger.debug("run: releasing consistencyService");
    // release the first one only
    serviceSemaphore.release(1);
    logger.debug("run: waiting 1sec");
    Thread.sleep(1000);
    assertFalse("should not be locked", lock.isLocked());
    // this should not have triggered any event 
    TestHelper.assertNoEvents(listener);
    // then release the 2nd one
    serviceSemaphore.release(1);
    logger.debug("run: waiting 1sec");
    Thread.sleep(1000);
    logger.debug("run: asserting 1 event");
    final TopologyEvent changedEvent = EventHelper.newChangedEvent(view1, view3);
    assertEvents(listener, changedEvent);
    // back to default
    commonsLogger.setLevel(Level.INFO);
}

56. AbstractSimpleTransportTestCase#testTracerLog()

Project: elasticsearch
File: AbstractSimpleTransportTestCase.java
@TestLogging(value = "test. transport.tracer:TRACE")
public void testTracerLog() throws InterruptedException {
    TransportRequestHandler handler = new TransportRequestHandler<StringMessageRequest>() {

        @Override
        public void messageReceived(StringMessageRequest request, TransportChannel channel) throws Exception {
            channel.sendResponse(new StringMessageResponse(""));
        }
    };
    TransportRequestHandler handlerWithError = new TransportRequestHandler<StringMessageRequest>() {

        @Override
        public void messageReceived(StringMessageRequest request, TransportChannel channel) throws Exception {
            if (request.timeout() > 0) {
                Thread.sleep(request.timeout);
            }
            channel.sendResponse(new RuntimeException(""));
        }
    };
    final Semaphore requestCompleted = new Semaphore(0);
    TransportResponseHandler noopResponseHandler = new BaseTransportResponseHandler<StringMessageResponse>() {

        @Override
        public StringMessageResponse newInstance() {
            return new StringMessageResponse();
        }

        @Override
        public void handleResponse(StringMessageResponse response) {
            requestCompleted.release();
        }

        @Override
        public void handleException(TransportException exp) {
            requestCompleted.release();
        }

        @Override
        public String executor() {
            return ThreadPool.Names.SAME;
        }
    };
    serviceA.registerRequestHandler("test", StringMessageRequest::new, ThreadPool.Names.SAME, handler);
    serviceA.registerRequestHandler("testError", StringMessageRequest::new, ThreadPool.Names.SAME, handlerWithError);
    serviceB.registerRequestHandler("test", StringMessageRequest::new, ThreadPool.Names.SAME, handler);
    serviceB.registerRequestHandler("testError", StringMessageRequest::new, ThreadPool.Names.SAME, handlerWithError);
    final Tracer tracer = new Tracer();
    serviceA.addTracer(tracer);
    serviceB.addTracer(tracer);
    tracer.reset(4);
    boolean timeout = randomBoolean();
    TransportRequestOptions options = timeout ? TransportRequestOptions.builder().withTimeout(1).build() : TransportRequestOptions.EMPTY;
    serviceA.sendRequest(nodeB, "test", new StringMessageRequest("", 10), options, noopResponseHandler);
    requestCompleted.acquire();
    tracer.expectedEvents.get().await();
    assertThat("didn't see request sent", tracer.sawRequestSent, equalTo(true));
    assertThat("didn't see request received", tracer.sawRequestReceived, equalTo(true));
    assertThat("didn't see response sent", tracer.sawResponseSent, equalTo(true));
    assertThat("didn't see response received", tracer.sawResponseReceived, equalTo(true));
    assertThat("saw error sent", tracer.sawErrorSent, equalTo(false));
    tracer.reset(4);
    serviceA.sendRequest(nodeB, "testError", new StringMessageRequest(""), noopResponseHandler);
    requestCompleted.acquire();
    tracer.expectedEvents.get().await();
    assertThat("didn't see request sent", tracer.sawRequestSent, equalTo(true));
    assertThat("didn't see request received", tracer.sawRequestReceived, equalTo(true));
    assertThat("saw response sent", tracer.sawResponseSent, equalTo(false));
    assertThat("didn't see response received", tracer.sawResponseReceived, equalTo(true));
    assertThat("didn't see error sent", tracer.sawErrorSent, equalTo(true));
    String includeSettings;
    String excludeSettings;
    if (randomBoolean()) {
        // sometimes leave include empty (default)
        includeSettings = randomBoolean() ? "*" : "";
        excludeSettings = "*Error";
    } else {
        includeSettings = "test";
        excludeSettings = "DOESN'T_MATCH";
    }
    ClusterSettings service = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    serviceA.setDynamicSettings(service);
    service.applySettings(Settings.builder().put(TransportService.TRACE_LOG_INCLUDE_SETTING.getKey(), includeSettings).put(TransportService.TRACE_LOG_EXCLUDE_SETTING.getKey(), excludeSettings).build());
    tracer.reset(4);
    serviceA.sendRequest(nodeB, "test", new StringMessageRequest(""), noopResponseHandler);
    requestCompleted.acquire();
    tracer.expectedEvents.get().await();
    assertThat("didn't see request sent", tracer.sawRequestSent, equalTo(true));
    assertThat("didn't see request received", tracer.sawRequestReceived, equalTo(true));
    assertThat("didn't see response sent", tracer.sawResponseSent, equalTo(true));
    assertThat("didn't see response received", tracer.sawResponseReceived, equalTo(true));
    assertThat("saw error sent", tracer.sawErrorSent, equalTo(false));
    tracer.reset(2);
    serviceA.sendRequest(nodeB, "testError", new StringMessageRequest(""), noopResponseHandler);
    requestCompleted.acquire();
    tracer.expectedEvents.get().await();
    assertThat("saw request sent", tracer.sawRequestSent, equalTo(false));
    assertThat("didn't see request received", tracer.sawRequestReceived, equalTo(true));
    assertThat("saw response sent", tracer.sawResponseSent, equalTo(false));
    assertThat("saw response received", tracer.sawResponseReceived, equalTo(false));
    assertThat("didn't see error sent", tracer.sawErrorSent, equalTo(true));
}

57. ServerCallsTest#inprocessTransportManualFlow()

Project: grpc-java
File: ServerCallsTest.java
@Test
public void inprocessTransportManualFlow() throws Exception {
    final Semaphore semaphore = new Semaphore(1);
    ServerServiceDefinition service = ServerServiceDefinition.builder(new ServiceDescriptor("some", STREAMING_METHOD)).addMethod(STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(new ServerCalls.BidiStreamingMethod<Integer, Integer>() {

        int iteration;

        @Override
        public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
            final ServerCallStreamObserver<Integer> serverCallObserver = (ServerCallStreamObserver<Integer>) responseObserver;
            serverCallObserver.setOnReadyHandler(new Runnable() {

                @Override
                public void run() {
                    while (serverCallObserver.isReady()) {
                        serverCallObserver.onNext(iteration);
                    }
                    iteration++;
                    semaphore.release();
                }
            });
            return new ServerCalls.NoopStreamObserver<Integer>() {

                @Override
                public void onCompleted() {
                    serverCallObserver.onCompleted();
                }
            };
        }
    })).build();
    long tag = System.nanoTime();
    InProcessServerBuilder.forName("go-with-the-flow" + tag).addService(service).build().start();
    ManagedChannelImpl channel = InProcessChannelBuilder.forName("go-with-the-flow" + tag).build();
    final ClientCall<Integer, Integer> clientCall = channel.newCall(STREAMING_METHOD, CallOptions.DEFAULT);
    final CountDownLatch latch = new CountDownLatch(1);
    final int[] receivedMessages = new int[6];
    clientCall.start(new ClientCall.Listener<Integer>() {

        int index;

        @Override
        public void onMessage(Integer message) {
            receivedMessages[index++] = message;
        }

        @Override
        public void onClose(Status status, Metadata trailers) {
            latch.countDown();
        }
    }, new Metadata());
    semaphore.acquire();
    clientCall.request(1);
    semaphore.acquire();
    clientCall.request(2);
    semaphore.acquire();
    clientCall.request(3);
    clientCall.halfClose();
    latch.await(5, TimeUnit.SECONDS);
    // Very that number of messages produced in each onReady handler call matches the number
    // requested by the client.
    assertArrayEquals(new int[] { 0, 1, 1, 2, 2, 2 }, receivedMessages);
}

58. ResourceRepoTest#testMultipleDownloads()

Project: bnd
File: ResourceRepoTest.java
public void testMultipleDownloads() throws Exception {
    final Semaphore s = new Semaphore(0);
    final AtomicInteger downloads = new AtomicInteger();
    ResourceDescriptor rd = create("jar/osgi.jar");
    repoImpl.add("x", rd);
    final Semaphore done = new Semaphore(0);
    DownloadListener l = new DownloadListener() {

        @Override
        public void success(File file) throws Exception {
            done.release();
        }

        @Override
        public void failure(File file, String reason) throws Exception {
            System.out.println("failure! " + file + " " + reason);
        }

        @Override
        public boolean progress(File file, int percentage) throws Exception {
            return false;
        }
    };
    repoImpl.addListener(new Listener() {

        @Override
        public void events(ResourceRepositoryEvent... events) throws Exception {
            for (ResourceRepositoryEvent event : events) {
                if (event.type == TYPE.START_DOWNLOAD) {
                    System.out.println("trying to acquire s");
                    s.acquire();
                    System.out.println("got it");
                    downloads.incrementAndGet();
                }
            }
        }
    });
    File f1 = repoImpl.getResource(rd.id, l);
    File f2 = repoImpl.getResource(rd.id, l);
    assertFalse(f1.isFile());
    assertFalse(f2.isFile());
    assertEquals(0, downloads.get());
    s.release();
    done.acquire(2);
    assertTrue(f1.isFile());
    assertTrue(f2.isFile());
    assertTrue(f1.equals(f2));
    assertEquals(1, downloads.get());
}

59. JmsBenchmark#testConcurrentSendReceive()

Project: activemq-artemis
File: JmsBenchmark.java
/**
    * @throws Throwable
    */
public void testConcurrentSendReceive() throws Throwable {
    final Semaphore connectionsEstablished = new Semaphore(1 - (CONSUMER_COUNT + PRODUCER_COUNT));
    final Semaphore workerDone = new Semaphore(1 - (CONSUMER_COUNT + PRODUCER_COUNT));
    final CountDownLatch sampleTimeDone = new CountDownLatch(1);
    final AtomicInteger producedMessages = new AtomicInteger(0);
    final AtomicInteger receivedMessages = new AtomicInteger(0);
    final Callable<Object> producer = new Callable<Object>() {

        @Override
        public Object call() throws JMSException, InterruptedException {
            Connection connection = factory.createConnection();
            connections.add(connection);
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageProducer producer = session.createProducer(destination);
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            BytesMessage message = session.createBytesMessage();
            message.writeBytes(new byte[1024]);
            connection.start();
            connectionsEstablished.release();
            while (!sampleTimeDone.await(0, TimeUnit.MILLISECONDS)) {
                producer.send(message);
                producedMessages.incrementAndGet();
            }
            connection.close();
            workerDone.release();
            return null;
        }
    };
    final Callable<Object> consumer = new Callable<Object>() {

        @Override
        public Object call() throws JMSException, InterruptedException {
            Connection connection = factory.createConnection();
            connections.add(connection);
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageConsumer consumer = session.createConsumer(destination);
            consumer.setMessageListener(new MessageListener() {

                @Override
                public void onMessage(Message msg) {
                    receivedMessages.incrementAndGet();
                }
            });
            connection.start();
            connectionsEstablished.release();
            sampleTimeDone.await();
            connection.close();
            workerDone.release();
            return null;
        }
    };
    final Throwable workerError[] = new Throwable[1];
    for (int i = 0; i < PRODUCER_COUNT; i++) {
        new Thread("Producer:" + i) {

            @Override
            public void run() {
                try {
                    producer.call();
                } catch (Throwable e) {
                    e.printStackTrace();
                    workerError[0] = e;
                }
            }
        }.start();
    }
    for (int i = 0; i < CONSUMER_COUNT; i++) {
        new Thread("Consumer:" + i) {

            @Override
            public void run() {
                try {
                    consumer.call();
                } catch (Throwable e) {
                    e.printStackTrace();
                    workerError[0] = e;
                }
            }
        }.start();
    }
    LOG.info(getName() + ": Waiting for Producers and Consumers to startup.");
    connectionsEstablished.acquire();
    LOG.info("Producers and Consumers are now running.  Waiting for system to reach steady state: " + (SAMPLE_DELAY / 1000.0f) + " seconds");
    Thread.sleep(1000 * 10);
    LOG.info("Starting sample: " + SAMPLES + " each lasting " + (SAMPLE_DURATION / 1000.0f) + " seconds");
    for (int i = 0; i < SAMPLES; i++) {
        long start = System.currentTimeMillis();
        producedMessages.set(0);
        receivedMessages.set(0);
        Thread.sleep(SAMPLE_DURATION);
        long end = System.currentTimeMillis();
        int r = receivedMessages.get();
        int p = producedMessages.get();
        LOG.info("published: " + p + " msgs at " + (p * 1000f / (end - start)) + " msgs/sec, " + "consumed: " + r + " msgs at " + (r * 1000f / (end - start)) + " msgs/sec");
    }
    LOG.info("Sample done.");
    sampleTimeDone.countDown();
    workerDone.acquire();
    if (workerError[0] != null) {
        throw workerError[0];
    }
}

60. TestBabySitter#testBabySitter()

Project: voltdb
File: TestBabySitter.java
@Test
public void testBabySitter() throws Exception {
    System.out.println("\t\t ***** Starting BabySitter testcase.");
    final Semaphore sem = new Semaphore(0);
    BabySitter.Callback cb = new BabySitter.Callback() {

        @Override
        public void run(List<String> children) {
            sem.release(1);
        }
    };
    ZooKeeper zk = getClient(0);
    zk.create("/babysitterroot", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    zk.create("/babysitterroot/c1", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    Pair<BabySitter, List<String>> pair = BabySitter.blockingFactory(zk, "/babysitterroot", cb);
    BabySitter bs = pair.getFirst();
    sem.acquire();
    assertTrue(bs.lastSeenChildren().size() == 1);
    assertTrue(pair.getSecond().size() == 1);
    zk.create("/babysitterroot/c2", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    sem.acquire();
    assertTrue(bs.lastSeenChildren().size() == 2);
    zk.delete("/babysitterroot/" + bs.lastSeenChildren().get(0), -1);
    sem.acquire();
    assertTrue(bs.lastSeenChildren().size() == 1);
    bs.shutdown();
}

61. ScopeTest#testThreadLocalScope()

Project: jodd
File: ScopeTest.java
@Test
public void testThreadLocalScope() throws InterruptedException {
    final PetiteContainer pc = new PetiteContainer();
    pc.registerPetiteBean(Foo.class, "foo", null, null, false);
    pc.registerPetiteBean(Zoo.class, null, null, null, false);
    pc.registerPetiteBean(Boo.class, null, ThreadLocalScope.class, null, false);
    assertEquals(3, pc.getTotalBeans());
    assertEquals(2, pc.getTotalScopes());
    final Boo boo = (Boo) pc.getBean("boo");
    final Foo foo = (Foo) pc.getBean("foo");
    assertSame(boo.getFoo(), foo);
    final Semaphore sem = new Semaphore(1);
    sem.acquire();
    Thread thread = new Thread() {

        @Override
        public void run() {
            Boo boo2 = (Boo) pc.getBean("boo");
            Foo foo2 = (Foo) pc.getBean("foo");
            assertSame(foo2, foo);
            assertNotSame(boo2, boo);
            assertSame(foo2, boo2.getFoo());
            sem.release();
        }
    };
    thread.start();
    sem.acquire();
    sem.release();
}

62. DocumentNodeStoreTest#rollback()

Project: jackrabbit-oak
File: DocumentNodeStoreTest.java
@Test
public void rollback() throws Exception {
    final Map<Thread, Semaphore> locks = Collections.synchronizedMap(new HashMap<Thread, Semaphore>());
    final Semaphore created = new Semaphore(0);
    DocumentStore docStore = new MemoryDocumentStore() {

        @Override
        public <T extends Document> List<T> createOrUpdate(Collection<T> collection, List<UpdateOp> updateOps) {
            Semaphore semaphore = locks.get(Thread.currentThread());
            List<T> result = super.createOrUpdate(collection, updateOps);
            if (semaphore != null) {
                created.release();
                semaphore.acquireUninterruptibly();
            }
            return result;
        }
    };
    final List<Exception> exceptions = new ArrayList<Exception>();
    final DocumentMK mk = builderProvider.newBuilder().setDocumentStore(docStore).setAsyncDelay(0).open();
    final DocumentNodeStore store = mk.getNodeStore();
    NodeBuilder builder = store.getRoot().builder();
    builder.child("deletedNode");
    builder.child("updateNode").setProperty("foo", "bar");
    merge(store, builder);
    builder = store.getRoot().builder();
    builder.child("deletedNode").remove();
    merge(store, builder);
    final RevisionVector head = store.getHeadRevision();
    Thread writer = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                Revision r = store.newRevision();
                Commit c = new Commit(store, r, head, null);
                c.addNode(new DocumentNodeState(store, "/newConflictingNode", new RevisionVector(r)));
                c.addNode(new DocumentNodeState(store, "/deletedNode", new RevisionVector(r)));
                c.updateProperty("/updateNode", "foo", "baz");
                c.apply();
            } catch (DocumentStoreException e) {
                exceptions.add(e);
            }
        }
    });
    final Semaphore s = new Semaphore(0);
    locks.put(writer, s);
    // will block in DocumentStore.create()
    writer.start();
    // wait for writer to create nodes
    created.acquireUninterruptibly();
    // commit will succeed and add collision marker to writer commit
    Revision r = store.newRevision();
    Commit c = new Commit(store, r, head, null);
    c.addNode(new DocumentNodeState(store, "/newConflictingNode", new RevisionVector(r)));
    c.addNode(new DocumentNodeState(store, "/newNonConflictingNode", new RevisionVector(r)));
    c.apply();
    // allow writer to continue
    s.release();
    writer.join();
    assertEquals("expected exception", 1, exceptions.size());
    String id = Utils.getIdFromPath("/newConflictingNode");
    NodeDocument doc = docStore.find(NODES, id);
    assertNotNull("document with id " + id + " does not exist", doc);
    assertTrue("document with id " + id + " should get _deletedOnce marked due to rollback", doc.wasDeletedOnce());
    id = Utils.getIdFromPath("/newNonConflictingNode");
    doc = docStore.find(NODES, id);
    assertNull("document with id " + id + " must not have _deletedOnce", doc.get(NodeDocument.DELETED_ONCE));
    id = Utils.getIdFromPath("/deletedNode");
    doc = docStore.find(NODES, id);
    assertTrue("document with id " + id + " should get _deletedOnce marked due to rollback", doc.wasDeletedOnce());
    id = Utils.getIdFromPath("/updateNode");
    doc = docStore.find(NODES, id);
    assertNull("document with id " + id + " must not have _deletedOnce despite rollback", doc.get(NodeDocument.DELETED_ONCE));
}

63. TestZK#testLeaderFailoverHarder()

Project: voltdb
File: TestZK.java
@Test
public void testLeaderFailoverHarder() throws Exception {
    // as above but put multiple failed nodes between the new and previous?
    ZooKeeper zk = getClient(0);
    ZooKeeper zk2 = getClient(1);
    ZooKeeper zk3 = getClient(2);
    ZooKeeper zk4 = getClient(3);
    zk.create("/election", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    final Semaphore sem2 = new Semaphore(0);
    LeaderNoticeHandler r2 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem2.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    final Semaphore sem3 = new Semaphore(0);
    LeaderNoticeHandler r3 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem3.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    final Semaphore sem4 = new Semaphore(0);
    LeaderNoticeHandler r4 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem4.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    LeaderElector elector1 = new LeaderElector(zk, "/election", "node", new byte[0], null);
    LeaderElector elector2 = new LeaderElector(zk2, "/election", "node", new byte[0], r2);
    LeaderElector elector3 = new LeaderElector(zk3, "/election", "node", new byte[0], r3);
    LeaderElector elector4 = new LeaderElector(zk4, "/election", "node", new byte[0], r4);
    elector1.start(true);
    elector2.start(true);
    elector3.start(true);
    elector4.start(true);
    assertTrue(elector1.isLeader());
    assertFalse(elector2.isLeader());
    assertFalse(elector3.isLeader());
    assertFalse(elector4.isLeader());
    // 4 should become the leader
    elector3.shutdown();
    zk3.close();
    elector2.shutdown();
    zk2.close();
    elector1.shutdown();
    zk.close();
    assertTrue(sem4.tryAcquire(5, TimeUnit.SECONDS));
    assertTrue(elector4.isLeader());
    // cleanup.
    elector4.shutdown();
    zk4.close();
}

64. TestZK#testChildWatches()

Project: voltdb
File: TestZK.java
@Test
public void testChildWatches() throws Exception {
    ZooKeeper zk = getClient(0);
    ZooKeeper zk2 = getClient(1);
    final Semaphore sem = new Semaphore(0);
    zk.exists("/foo", new Watcher() {

        @Override
        public void process(WatchedEvent event) {
            if (event.getType() == EventType.NodeCreated) {
                sem.release();
                System.out.println(event);
            }
        }
    });
    zk2.create("/foo", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    sem.tryAcquire(5, TimeUnit.SECONDS);
    zk.create("/foo2", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    zk2.exists("/foo2", new Watcher() {

        @Override
        public void process(WatchedEvent event) {
            if (event.getType() == EventType.NodeDeleted) {
                sem.release();
                System.out.println(event);
            }
        }
    });
    zk.delete("/foo2", -1);
    sem.acquire();
}

65. TestBabySitter#testChildrenOrdering()

Project: voltdb
File: TestBabySitter.java
@Test
public void testChildrenOrdering() throws Exception {
    final Semaphore sem = new Semaphore(0);
    final AtomicReference<List<String>> latestChildren = new AtomicReference<List<String>>();
    BabySitter.Callback cb = new BabySitter.Callback() {

        @Override
        public void run(List<String> children) {
            latestChildren.set(children);
            sem.release();
        }
    };
    ZooKeeper zk = getClient(0);
    zk.create("/babysitterroot", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    final String node6 = zk.create("/babysitterroot/6_", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    zk.create("/babysitterroot/7_", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    zk.create("/babysitterroot/10_", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    Pair<BabySitter, List<String>> pair = BabySitter.blockingFactory(zk, "/babysitterroot", cb);
    BabySitter bs = pair.getFirst();
    sem.acquire();
    assertEquals(Lists.newArrayList(6l, 7l, 10l), VoltZK.childrenToReplicaHSIds(latestChildren.get()));
    zk.delete(node6, -1);
    sem.acquire();
    assertEquals(Lists.newArrayList(7l, 10l), VoltZK.childrenToReplicaHSIds(latestChildren.get()));
    bs.shutdown();
}

66. CoalescingStrategiesTest#parkLoop()

Project: stratio-cassandra
File: CoalescingStrategiesTest.java
@Test
public void parkLoop() throws Exception {
    final Thread current = Thread.currentThread();
    final Semaphore helperReady = new Semaphore(0);
    final Semaphore helperGo = new Semaphore(0);
    new Thread() {

        @Override
        public void run() {
            try {
                helperReady.release();
                helperGo.acquire();
                Thread.sleep(50);
                LockSupport.unpark(current);
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("Error", e);
                System.exit(-1);
            }
        }
    }.start();
    long start = System.nanoTime();
    helperGo.release();
    long parkNanos = TimeUnit.MILLISECONDS.toNanos(500);
    CoalescingStrategies.parkLoop(parkNanos);
    long delta = System.nanoTime() - start;
    assertTrue(delta >= (parkNanos - (parkNanos / 16)));
}

67. TestViewStateManager#testClusterSyncService_noConcurrency()

Project: sling
File: TestViewStateManager.java
@Test
public void testClusterSyncService_noConcurrency() throws Exception {
    final org.apache.log4j.Logger commonsLogger = LogManager.getRootLogger().getLogger("org.apache.sling.discovery.commons.providers");
    final org.apache.log4j.Level logLevel = commonsLogger.getLevel();
    // change here to DEBUG in case of issues with this test
    commonsLogger.setLevel(Level.INFO);
    final Semaphore serviceSemaphore = new Semaphore(0);
    final ReentrantLock lock = new ReentrantLock();
    final ClusterSyncServiceWithSemaphore cs = new ClusterSyncServiceWithSemaphore(lock, serviceSemaphore);
    mgr = new ViewStateManagerImpl(lock, cs);
    final DummyListener listener = new DummyListener();
    mgr.bind(listener);
    TestHelper.assertNoEvents(listener);
    mgr.handleActivated();
    TestHelper.assertNoEvents(listener);
    final String slingId1 = UUID.randomUUID().toString();
    final String slingId2 = UUID.randomUUID().toString();
    final String clusterId = UUID.randomUUID().toString();
    final DefaultClusterView cluster = new DefaultClusterView(clusterId);
    final DummyTopologyView view1 = new DummyTopologyView().addInstance(slingId1, cluster, true, true).addInstance(slingId2, cluster, false, false);
    async(new Runnable() {

        public void run() {
            mgr.handleNewView(view1);
        }
    });
    Thread.sleep(1000);
    TestHelper.assertNoEvents(listener);
    serviceSemaphore.release(1);
    Thread.sleep(1000);
    assertEvents(listener, EventHelper.newInitEvent(view1));
    final DummyTopologyView view2 = view1.clone();
    mgr.handleChanging();
    assertEvents(listener, EventHelper.newChangingEvent(view1));
    view2.removeInstance(slingId2);
    async(new Runnable() {

        public void run() {
            mgr.handleNewView(view2);
        }
    });
    logger.debug("run: waiting for 1sec");
    Thread.sleep(1000);
    logger.debug("run: asserting no events");
    TestHelper.assertNoEvents(listener);
    logger.debug("run: releasing consistencyService");
    serviceSemaphore.release(1);
    logger.debug("run: waiting 1sec");
    Thread.sleep(1000);
    logger.debug("run: asserting 1 event");
    assertEvents(listener, EventHelper.newChangedEvent(view1, view2));
    // back to default
    commonsLogger.setLevel(Level.INFO);
}

68. FormulaEvaluatorTest#testThreading()

Project: lumify
File: FormulaEvaluatorTest.java
@Test
public void testThreading() throws InterruptedException {
    Thread[] threads = new Thread[4];
    final AtomicInteger threadsReadyCount = new AtomicInteger();
    final Semaphore block = new Semaphore(threads.length);
    block.acquire(threads.length);
    // prime the main thread for evaluation
    assertEquals("Prop A Value, Prop B Value", evaluator.evaluateTitleFormula(null, userContext, null));
    for (int i = 0; i < threads.length; i++) {
        threads[i] = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    // prime this thread for evaluation
                    evaluator.evaluateTitleFormula(null, userContext, null);
                    threadsReadyCount.incrementAndGet();
                    // wait to run the look
                    block.acquire();
                    for (int i = 0; i < 20; i++) {
                        System.out.println(Thread.currentThread().getName() + " - " + i);
                        assertEquals("Prop A Value, Prop B Value", evaluator.evaluateTitleFormula(null, userContext, null));
                    }
                    System.out.println(Thread.currentThread().getName() + " - closing evaluator");
                    evaluator.close();
                    System.out.println(Thread.currentThread().getName() + " - evaluator closed");
                } catch (Exception ex) {
                    throw new RuntimeException("Could not run", ex);
                }
            }
        });
        threads[i].setName(FormulaEvaluatorTest.class.getSimpleName() + "-testThreading-" + i);
    }
    for (Thread thread : threads) {
        thread.start();
    }
    // wait for all threads to be primed
    while (threadsReadyCount.get() < threads.length) {
        Thread.sleep(100);
    }
    block.release(threads.length);
    // wait for threads to finish
    for (Thread thread : threads) {
        synchronized (thread) {
            thread.join();
        }
    }
    // make sure the main threads evaluator isn't broken.
    assertEquals("Prop A Value, Prop B Value", evaluator.evaluateTitleFormula(null, userContext, null));
    evaluator.close();
}

69. TestPluginOperation#testLocking()

Project: killbill
File: TestPluginOperation.java
private void testLocking() throws Exception {
    final Semaphore available = new Semaphore(1, true);
    final CallbackTest callback = new CallbackTest(available);
    final PaymentOperation pluginOperation = getPluginOperation(true);
    // Take the only permit
    available.acquire();
    // Start the plugin operation in the background (will block)
    runPluginOperationInBackground(pluginOperation, callback, false);
    Awaitility.await().until(new Callable<Boolean>() {

        @Override
        public Boolean call() throws Exception {
            return callback.getStartCount() == 1;
        }
    });
    // The operation should be blocked here because we have the semaphore
    Assert.assertEquals(callback.getRunCount(), 0);
    // Trying to run the operation again will throw LockFailedException
    Awaitility.await().atMost(2 * TIMEOUT, TimeUnit.SECONDS).untilTrue(runPluginOperationInBackground(pluginOperation, callback, true));
    Assert.assertEquals(callback.getRunCount(), 0);
    // Release the semaphore
    available.release();
    // Give some time for the operation to run
    Awaitility.await().until(new Callable<Boolean>() {

        @Override
        public Boolean call() throws Exception {
            return callback.getRunCount() == 1;
        }
    });
    // Verify the final state
    Assert.assertEquals(available.availablePermits(), 1);
}

70. AsyncIndexUpdateTest#abortedRun()

Project: jackrabbit-oak
File: AsyncIndexUpdateTest.java
@Test
public void abortedRun() throws Exception {
    NodeStore store = new MemoryNodeStore();
    IndexEditorProvider provider = new PropertyIndexEditorProvider();
    NodeBuilder builder = store.getRoot().builder();
    createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "rootIndex", true, false, ImmutableSet.of("foo"), null).setProperty(ASYNC_PROPERTY_NAME, "async");
    builder.child("testRoot").setProperty("foo", "abc");
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    final Semaphore asyncLock = new Semaphore(1);
    final AsyncIndexUpdate async = new AsyncIndexUpdate("async", store, provider) {

        @Override
        protected AsyncUpdateCallback newAsyncUpdateCallback(NodeStore store, String name, long leaseTimeOut, String beforeCheckpoint, String afterCheckpoint, AsyncIndexStats indexStats, AtomicBoolean stopFlag) {
            return new AsyncUpdateCallback(store, name, leaseTimeOut, beforeCheckpoint, afterCheckpoint, indexStats, stopFlag) {

                @Override
                public void indexUpdate() throws CommitFailedException {
                    try {
                        asyncLock.acquire();
                    } catch (InterruptedException ignore) {
                    }
                    try {
                        super.indexUpdate();
                    } finally {
                        asyncLock.release();
                    }
                }
            };
        }
    };
    runOneCycle(async);
    assertEquals(IndexStatsMBean.STATUS_DONE, async.getIndexStats().getStatus());
    //Below we ensure that we interrupt while the indexing is in progress
    //hence the use of asyncLock which ensures the abort is called at right time
    //Now make some changes to
    builder = store.getRoot().builder();
    builder.child("testRoot2").setProperty("foo", "abc");
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    Thread t = new Thread(async);
    //Lock to ensure that AsyncIndexUpdate waits
    asyncLock.acquire();
    t.start();
    //Wait till async gets to wait state i.e. inside run
    while (!asyncLock.hasQueuedThreads()) ;
    assertEquals(IndexStatsMBean.STATUS_RUNNING, async.getIndexStats().getStatus());
    assertThat(async.getIndexStats().abortAndPause(), containsString("Abort request placed"));
    asyncLock.release();
    retry(5, 5, new Callable<Boolean>() {

        @Override
        public Boolean call() throws Exception {
            return IndexStatsMBean.STATUS_INTERRUPTED.equals(async.getIndexStats().getStatus());
        }
    });
    //Post abort indexing should be fine
    runOneCycle(async);
    assertTrue(async.getIndexStats().isPaused());
    //Now resume indexing
    async.getIndexStats().resume();
    runOneCycle(async);
    assertEquals(IndexStatsMBean.STATUS_DONE, async.getIndexStats().getStatus());
    assertFalse(async.isClosed());
}

71. AsyncIndexUpdateTest#closeWithHardLimit()

Project: jackrabbit-oak
File: AsyncIndexUpdateTest.java
@Test
public void closeWithHardLimit() throws Exception {
    NodeStore store = new MemoryNodeStore();
    IndexEditorProvider provider = new PropertyIndexEditorProvider();
    NodeBuilder builder = store.getRoot().builder();
    createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "rootIndex", true, false, ImmutableSet.of("foo"), null).setProperty(ASYNC_PROPERTY_NAME, "async");
    builder.child("testRoot").setProperty("foo", "abc");
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    final Semaphore asyncLock = new Semaphore(1);
    final AsyncIndexUpdate async = new AsyncIndexUpdate("async", store, provider) {

        @Override
        protected AsyncUpdateCallback newAsyncUpdateCallback(NodeStore store, String name, long leaseTimeOut, String beforeCheckpoint, String afterCheckpoint, AsyncIndexStats indexStats, AtomicBoolean stopFlag) {
            try {
                asyncLock.acquire();
            } catch (InterruptedException ignore) {
            }
            return super.newAsyncUpdateCallback(store, name, leaseTimeOut, beforeCheckpoint, afterCheckpoint, indexStats, stopFlag);
        }
    };
    //Set a 1 sec close timeout
    async.setCloseTimeOut(1);
    Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            async.run();
        }
    });
    Thread closer = new Thread(new Runnable() {

        @Override
        public void run() {
            async.close();
        }
    });
    //Lock to ensure that AsyncIndexUpdate waits
    asyncLock.acquire();
    t.start();
    //Wait till async gets to wait state i.e. inside run
    while (!asyncLock.hasQueuedThreads()) ;
    LogCustomizer lc = createLogCustomizer(Level.DEBUG);
    closer.start();
    //Wait till stopFlag is set
    while (!async.isClosed()) ;
    assertLogPhrase(lc.getLogs(), "[SOFT LIMIT HIT]");
    //Let indexing run complete now
    asyncLock.release();
    //Wait for both threads
    t.join();
    //Async run would have exited with log message logged
    assertLogPhrase(lc.getLogs(), "The index update interrupted");
    //Wait for close call to complete
    closer.join();
    lc.finished();
}

72. AsyncIndexUpdateTest#closeWithSoftLimit()

Project: jackrabbit-oak
File: AsyncIndexUpdateTest.java
@Test
public void closeWithSoftLimit() throws Exception {
    NodeStore store = new MemoryNodeStore();
    IndexEditorProvider provider = new PropertyIndexEditorProvider();
    NodeBuilder builder = store.getRoot().builder();
    createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), "rootIndex", true, false, ImmutableSet.of("foo"), null).setProperty(ASYNC_PROPERTY_NAME, "async");
    builder.child("testRoot").setProperty("foo", "abc");
    store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY);
    final Semaphore asyncLock = new Semaphore(1);
    final AsyncIndexUpdate async = new AsyncIndexUpdate("async", store, provider) {

        @Override
        protected AsyncUpdateCallback newAsyncUpdateCallback(NodeStore store, String name, long leaseTimeOut, String beforeCheckpoint, String afterCheckpoint, AsyncIndexStats indexStats, AtomicBoolean stopFlag) {
            try {
                asyncLock.acquire();
            } catch (InterruptedException ignore) {
            }
            return super.newAsyncUpdateCallback(store, name, leaseTimeOut, beforeCheckpoint, afterCheckpoint, indexStats, stopFlag);
        }
    };
    async.setCloseTimeOut(1000);
    Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            async.run();
        }
    });
    Thread closer = new Thread(new Runnable() {

        @Override
        public void run() {
            async.close();
        }
    });
    asyncLock.acquire();
    t.start();
    //Wait till async gets to wait state i.e. inside run
    while (!asyncLock.hasQueuedThreads()) ;
    LogCustomizer lc = createLogCustomizer(Level.DEBUG);
    closer.start();
    //Wait till closer is in waiting state
    while (!async.isClosing()) ;
    //For softLimit case the flag should not be set
    assertFalse(async.isClosed());
    assertLogPhrase(lc.getLogs(), "[WAITING]");
    //Let indexing run complete now
    asyncLock.release();
    //Wait for both threads
    t.join();
    closer.join();
    //Close call should complete
    assertLogPhrase(lc.getLogs(), "[CLOSED OK]");
}

73. TestPartitionExecutorSpecExec#testIdleSpeculation()

Project: h-store
File: TestPartitionExecutorSpecExec.java
// --------------------------------------------------------------------------------------------
// TEST CASES
// --------------------------------------------------------------------------------------------
/**
     * testIdleSpeculation
     */
@Test
public void testIdleSpeculation() throws Throwable {
    // Check that we can speculative execute txns whenever the
    // PartitionExecutor is idle waiting to start a txn that still 
    // hasn't gotten all of the locks that it needs.
    boolean result;
    // First fire off a single-partition txn that will block
    int marker = 1000;
    Semaphore spLock = new Semaphore(0);
    SinglePartitionTester.LOCK_BEFORE.put(marker, spLock);
    Semaphore spNotify = new Semaphore(0);
    SinglePartitionTester.NOTIFY_BEFORE.put(marker, spNotify);
    LatchableProcedureCallback spCallback0 = new LatchableProcedureCallback(1);
    Object params[] = new Object[] { BASE_PARTITION, marker, 0 };
    Procedure spProc = this.getProcedure(SinglePartitionTester.class);
    this.client.callProcedure(spCallback0, spProc.getName(), params);
    // Block until we know that the txn has started running
    result = spNotify.tryAcquire(NOTIFY_TIMEOUT, TimeUnit.MILLISECONDS);
    assertTrue(result);
    // Then execute a distributed txn. It will get the lock for the
    // other partition that the first partition isn't running on
    Object dtxnParams[] = new Object[] { BASE_PARTITION + 1 };
    this.client.callProcedure(this.dtxnCallback, this.dtxnProc.getName(), dtxnParams);
    ThreadUtil.sleep(NOTIFY_TIMEOUT);
    // Now blast out a single-partition txn that will get
    // speculatively executed on the idle partition
    LatchableProcedureCallback spCallback1 = new LatchableProcedureCallback(1);
    params = new Object[] { BASE_PARTITION + 1, marker + 1, 0 };
    this.client.callProcedure(spCallback1, spProc.getName(), params);
    result = spCallback1.latch.await(NOTIFY_TIMEOUT, TimeUnit.MILLISECONDS);
    assertTrue("SINGLE-P1 LATCH: " + spCallback1.latch, result);
    assertEquals(1, spCallback1.responses.size());
    this.checkClientResponses(spCallback1.responses, Status.OK, true, 0);
    // Release all the locks and let this one fly
    assertEquals(0, spCallback0.responses.size());
    spLock.release();
    this.lockBefore.release();
    this.lockAfter.release();
    // Everyone else should succeed and not be speculative. 
    result = this.dtxnLatch.await(NOTIFY_TIMEOUT, TimeUnit.MILLISECONDS);
    assertTrue("DTXN LATCH" + this.dtxnLatch, result);
    assertEquals(Status.OK, this.dtxnResponse.getStatus());
    result = spCallback0.latch.await(NOTIFY_TIMEOUT, TimeUnit.MILLISECONDS);
    assertTrue("SINGLE-P0 LATCH" + spCallback0.latch, result);
    assertEquals(1, spCallback0.responses.size());
    this.checkClientResponses(spCallback0.responses, Status.OK, false, 0);
}

74. ClientCallsTest#inprocessTransportInboundFlowControl()

Project: grpc-java
File: ClientCallsTest.java
@Test
public void inprocessTransportInboundFlowControl() throws Exception {
    final Semaphore semaphore = new Semaphore(0);
    ServerServiceDefinition service = ServerServiceDefinition.builder(new ServiceDescriptor("some", STREAMING_METHOD)).addMethod(STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(new ServerCalls.BidiStreamingMethod<Integer, Integer>() {

        int iteration;

        @Override
        public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
            final ServerCallStreamObserver<Integer> serverCallObserver = (ServerCallStreamObserver<Integer>) responseObserver;
            serverCallObserver.setOnReadyHandler(new Runnable() {

                @Override
                public void run() {
                    while (serverCallObserver.isReady()) {
                        serverCallObserver.onNext(iteration);
                    }
                    iteration++;
                    semaphore.release();
                }
            });
            return new ServerCalls.NoopStreamObserver<Integer>() {

                @Override
                public void onCompleted() {
                    serverCallObserver.onCompleted();
                }
            };
        }
    })).build();
    long tag = System.nanoTime();
    server = InProcessServerBuilder.forName("go-with-the-flow" + tag).directExecutor().addService(service).build().start();
    channel = InProcessChannelBuilder.forName("go-with-the-flow" + tag).directExecutor().build();
    final ClientCall<Integer, Integer> clientCall = channel.newCall(STREAMING_METHOD, CallOptions.DEFAULT);
    final CountDownLatch latch = new CountDownLatch(1);
    final List<Object> receivedMessages = new ArrayList<Object>(6);
    ClientResponseObserver<Integer, Integer> responseObserver = new ClientResponseObserver<Integer, Integer>() {

        @Override
        public void beforeStart(final ClientCallStreamObserver<Integer> requestStream) {
            requestStream.disableAutoInboundFlowControl();
        }

        @Override
        public void onNext(Integer value) {
            receivedMessages.add(value);
        }

        @Override
        public void onError(Throwable t) {
            receivedMessages.add(t);
            latch.countDown();
        }

        @Override
        public void onCompleted() {
            latch.countDown();
        }
    };
    CallStreamObserver<Integer> integerStreamObserver = (CallStreamObserver<Integer>) ClientCalls.asyncBidiStreamingCall(clientCall, responseObserver);
    semaphore.acquire();
    integerStreamObserver.request(2);
    semaphore.acquire();
    integerStreamObserver.request(3);
    integerStreamObserver.onCompleted();
    assertTrue(latch.await(5, TimeUnit.SECONDS));
    // Verify that number of messages produced in each onReady handler call matches the number
    // requested by the client. Note that ClientCalls.asyncBidiStreamingCall will request(1)
    assertEquals(Arrays.asList(0, 1, 1, 2, 2, 2), receivedMessages);
}

75. ArtifactsDiskCleanerTest#shouldTriggerCleanupWhenLimitReached()

Project: gocd
File: ArtifactsDiskCleanerTest.java
@Test(timeout = 20 * 1000)
public void shouldTriggerCleanupWhenLimitReached() throws InterruptedException {
    serverConfig.setPurgeLimits(20.0, 30.0);
    final boolean[] artifactsDeletionTriggered = { false };
    final Thread[] artifactDeleterThread = { null };
    final Semaphore sem = new Semaphore(1);
    sem.acquire();
    artifactsDiskCleaner = new ArtifactsDiskCleaner(sysEnv, goConfigService, diskSpaceChecker, artifactService, stageService, configDbStateRepository) {

        @Override
        void deleteOldArtifacts() {
            artifactDeleterThread[0] = Thread.currentThread();
            artifactsDeletionTriggered[0] = true;
            sem.release();
        }
    };
    Thread cleaner = (Thread) ReflectionUtil.getField(artifactsDiskCleaner, "cleaner");
    while (true) {
        if (cleaner.getState().equals(Thread.State.WAITING)) {
            break;
        }
        Thread.sleep(5);
    }
    artifactsDiskCleaner.createFailure(new HttpOperationResult(), 10, 100);
    sem.acquire();
    assertThat(artifactsDeletionTriggered[0], is(true));
    assertThat(artifactDeleterThread[0], not(sameInstance(Thread.currentThread())));
}

76. BuildAssignmentServiceIntegrationTest#shouldNotReloadScheduledJobPlansWhenAgentWorkAssignmentIsInProgress()

Project: gocd
File: BuildAssignmentServiceIntegrationTest.java
@Test
public void shouldNotReloadScheduledJobPlansWhenAgentWorkAssignmentIsInProgress() throws Exception {
    fixture.createPipelineWithFirstStageScheduled();
    Pipeline pipeline = pipelineDao.mostRecentPipeline(fixture.pipelineName);
    JobInstance job = pipeline.getFirstStage().getJobInstances().first();
    final JobInstanceService mockJobInstanceService = mock(JobInstanceService.class);
    final Pipeline pipeline1 = pipeline;
    final Semaphore sem = new Semaphore(1);
    sem.acquire();
    when(mockJobInstanceService.orderedScheduledBuilds()).thenReturn(jobInstanceService.orderedScheduledBuilds());
    when(mockJobInstanceService.buildByIdWithTransitions(job.getId())).thenReturn(jobInstanceService.buildByIdWithTransitions(job.getId()));
    ScheduledPipelineLoader scheduledPipelineLoader = new ScheduledPipelineLoader(null, null, null, null, null, null, null, null) {

        @Override
        public Pipeline pipelineWithPasswordAwareBuildCauseByBuildId(long buildId) {
            sem.release();
            sleepQuietly(1000);
            verify(mockJobInstanceService, times(1)).orderedScheduledBuilds();
            return pipeline1;
        }
    };
    final BuildAssignmentService buildAssignmentServiceUnderTest = new BuildAssignmentService(goConfigService, mockJobInstanceService, scheduleService, agentService, environmentConfigService, transactionTemplate, scheduledPipelineLoader, pipelineService, builderFactory, agentRemoteHandler);
    final Throwable[] fromThread = new Throwable[1];
    buildAssignmentServiceUnderTest.onTimer();
    Thread assigner = new Thread(new Runnable() {

        public void run() {
            try {
                final AgentConfig agentConfig = AgentMother.localAgentWithResources("some-other-resource");
                buildAssignmentServiceUnderTest.assignWorkToAgent(agent(agentConfig));
            } catch (Throwable e) {
                e.printStackTrace();
                fromThread[0] = e;
            } finally {
            }
        }
    }, "assignmentThread");
    assigner.start();
    sem.acquire();
    buildAssignmentServiceUnderTest.onTimer();
    assigner.join();
    assertThat(fromThread[0], is(nullValue()));
}

77. CoalescingStrategiesTest#parkLoop()

Project: cassandra
File: CoalescingStrategiesTest.java
@Test
public void parkLoop() throws Exception {
    final Thread current = Thread.currentThread();
    final Semaphore helperReady = new Semaphore(0);
    final Semaphore helperGo = new Semaphore(0);
    new Thread() {

        @Override
        public void run() {
            try {
                helperReady.release();
                helperGo.acquire();
                Thread.sleep(50);
                LockSupport.unpark(current);
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("Error", e);
                System.exit(-1);
            }
        }
    }.start();
    long start = System.nanoTime();
    helperGo.release();
    long parkNanos = TimeUnit.MILLISECONDS.toNanos(500);
    CoalescingStrategies.parkLoop(parkNanos);
    long delta = System.nanoTime() - start;
    assertTrue(delta >= (parkNanos - (parkNanos / 16)));
}

78. FutureCallbackMethodRunnerTest#check()

Project: caesar
File: FutureCallbackMethodRunnerTest.java
private <T> boolean check(final Consumer<FutureCallback<T>> operation, final FutureCallback<T> callback, final boolean failOnError) throws Throwable {
    final AtomicReference<Throwable> error = new AtomicReference<>();
    final Semaphore semaphore = new Semaphore(1, true);
    semaphore.acquire();
    final FutureCallback<T> semaphoreCallback = new FutureCallback<T>() {

        public void onSuccess(final T result) {
            try {
                callback.onSuccess(result);
            } finally {
                semaphore.release();
            }
        }

        public void onFailure(final Throwable caught) {
            try {
                error.set(caught);
                callback.onFailure(caught);
            } finally {
                semaphore.release();
            }
        }
    };
    operation.set(semaphoreCallback);
    semaphore.acquire();
    if (failOnError) {
        final Throwable throwable = error.get();
        if (throwable != null) {
            throw throwable;
        }
    }
    return true;
}

79. AsyncCallbackMethodRunnerTest#check()

Project: caesar
File: AsyncCallbackMethodRunnerTest.java
private <T> boolean check(final Consumer<AsyncCallback<T>> operation, final AsyncCallback<T> callback, final boolean failOnError) throws Throwable {
    final AtomicReference<Throwable> error = new AtomicReference<>();
    final Semaphore semaphore = new Semaphore(1, true);
    semaphore.acquire();
    final AsyncCallback<T> semaphoreCallback = new AsyncCallback<T>() {

        public void onSuccess(final T result) {
            try {
                callback.onSuccess(result);
            } finally {
                semaphore.release();
            }
        }

        public void onFailure(final Throwable caught) {
            try {
                error.set(caught);
                callback.onFailure(caught);
            } finally {
                semaphore.release();
            }
        }
    };
    operation.set(semaphoreCallback);
    semaphore.acquire();
    if (failOnError) {
        final Throwable throwable = error.get();
        if (throwable != null) {
            throw throwable;
        }
    }
    return true;
}

80. HangConsumerTest#testHangDuplicateQueues()

Project: activemq-artemis
File: HangConsumerTest.java
/**
    * This would recreate the scenario where a queue was duplicated
    *
    * @throws Exception
    */
@Test
public void testHangDuplicateQueues() throws Exception {
    final Semaphore blocked = new Semaphore(1);
    final CountDownLatch latchDelete = new CountDownLatch(1);
    class MyQueueWithBlocking extends QueueImpl {

        /**
          * @param id
          * @param address
          * @param name
          * @param filter
          * @param pageSubscription
          * @param durable
          * @param temporary
          * @param scheduledExecutor
          * @param postOffice
          * @param storageManager
          * @param addressSettingsRepository
          * @param executor
          */
        MyQueueWithBlocking(final long id, final SimpleString address, final SimpleString name, final Filter filter, final SimpleString user, final PageSubscription pageSubscription, final boolean durable, final boolean temporary, final boolean autoCreated, final ScheduledExecutorService scheduledExecutor, final PostOffice postOffice, final StorageManager storageManager, final HierarchicalRepository<AddressSettings> addressSettingsRepository, final Executor executor) {
            super(id, address, name, filter, pageSubscription, user, durable, temporary, autoCreated, scheduledExecutor, postOffice, storageManager, addressSettingsRepository, executor);
        }

        @Override
        public synchronized int deleteMatchingReferences(final int flushLimit, final Filter filter) throws Exception {
            latchDelete.countDown();
            blocked.acquire();
            blocked.release();
            return super.deleteMatchingReferences(flushLimit, filter);
        }

        @Override
        public void deliverScheduledMessages() {
        }
    }
    class LocalFactory extends QueueFactoryImpl {

        LocalFactory(final ExecutorFactory executorFactory, final ScheduledExecutorService scheduledExecutor, final HierarchicalRepository<AddressSettings> addressSettingsRepository, final StorageManager storageManager) {
            super(executorFactory, scheduledExecutor, addressSettingsRepository, storageManager);
        }

        @Override
        public Queue createQueue(final long persistenceID, final SimpleString address, final SimpleString name, final Filter filter, final PageSubscription pageSubscription, final SimpleString user, final boolean durable, final boolean temporary, final boolean autoCreated) {
            queue = new MyQueueWithBlocking(persistenceID, address, name, filter, user, pageSubscription, durable, temporary, autoCreated, scheduledExecutor, postOffice, storageManager, addressSettingsRepository, executorFactory.getExecutor());
            return queue;
        }
    }
    LocalFactory queueFactory = new LocalFactory(server.getExecutorFactory(), server.getScheduledPool(), server.getAddressSettingsRepository(), server.getStorageManager());
    queueFactory.setPostOffice(server.getPostOffice());
    ((ActiveMQServerImpl) server).replaceQueueFactory(queueFactory);
    queue = server.createQueue(QUEUE, QUEUE, null, true, false);
    blocked.acquire();
    ClientSessionFactory factory = locator.createSessionFactory();
    ClientSession session = factory.createSession(false, false, false);
    ClientProducer producer = session.createProducer(QUEUE);
    producer.send(session.createMessage(true));
    session.commit();
    Thread tDelete = new Thread() {

        @Override
        public void run() {
            try {
                server.destroyQueue(QUEUE);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };
    tDelete.start();
    Assert.assertTrue(latchDelete.await(10, TimeUnit.SECONDS));
    try {
        server.createQueue(QUEUE, QUEUE, null, true, false);
    } catch (Exception expected) {
    }
    blocked.release();
    server.stop();
    tDelete.join();
    session.close();
    // a duplicate binding would impede the server from starting
    server.start();
    waitForServerToStart(server);
    server.stop();
}

81. TestRecoveryHdfs#testCleanShutdown()

Project: lucene-solr
File: TestRecoveryHdfs.java
// make sure that log isn't needlessly replayed after a clean close
@Test
public void testCleanShutdown() throws Exception {
    DirectUpdateHandler2.commitOnClose = true;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = () -> logReplayFinish.release();
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    try {
        clearIndex();
        assertU(commit());
        assertU(adoc("id", "E1", "val_i", "1"));
        assertU(adoc("id", "E2", "val_i", "1"));
        // set to a high enough number so this test won't hang on a bug
        logReplay.release(10);
        h.close();
        createCore();
        // make sure the docs got committed
        assertJQ(req("q", "*:*"), "/response/numFound==2");
        // make sure no replay happened
        assertEquals(10, logReplay.availablePermits());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

82. TestRecoveryHdfs#testDropBuffered()

Project: lucene-solr
File: TestRecoveryHdfs.java
@Test
@Ignore("HDFS-3107: no truncate support yet")
public void testDropBuffered() throws Exception {
    DirectUpdateHandler2.commitOnClose = false;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = logReplayFinish::release;
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    try {
        clearIndex();
        assertU(commit());
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        Future<UpdateLog.RecoveryInfo> rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture == null);
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        // simulate updates from a leader
        updateJ(jsonAdd(sdoc("id", "C1", "_version_", "101")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C2", "_version_", "102")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C3", "_version_", "103")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertTrue(ulog.dropBufferedUpdates());
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "C4", "_version_", "104")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C5", "_version_", "105")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        logReplay.release(1000);
        rinfoFuture = ulog.applyBufferedUpdates();
        UpdateLog.RecoveryInfo rinfo = rinfoFuture.get();
        assertEquals(2, rinfo.adds);
        assertJQ(req("qt", "/get", "getVersions", "2"), "=={'versions':[105,104]}");
        // this time add some docs first before buffering starts (so tlog won't be at pos 0)
        updateJ(jsonAdd(sdoc("id", "C100", "_version_", "200")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C101", "_version_", "201")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "C103", "_version_", "203")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C104", "_version_", "204")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertTrue(ulog.dropBufferedUpdates());
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "C105", "_version_", "205")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C106", "_version_", "206")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        rinfoFuture = ulog.applyBufferedUpdates();
        rinfo = rinfoFuture.get();
        assertEquals(2, rinfo.adds);
        assertJQ(req("q", "*:*", "sort", "_version_ asc", "fl", "id,_version_"), "/response/docs==[" + "{'id':'C4','_version_':104}" + ",{'id':'C5','_version_':105}" + ",{'id':'C100','_version_':200}" + ",{'id':'C101','_version_':201}" + ",{'id':'C105','_version_':205}" + ",{'id':'C106','_version_':206}" + "]");
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[206,205,201,200,105,104]}");
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        updateJ(jsonAdd(sdoc("id", "C301", "_version_", "998")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C302", "_version_", "999")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertTrue(ulog.dropBufferedUpdates());
        // make sure we can overwrite with a lower version
        // TODO: is this functionality needed?
        updateJ(jsonAdd(sdoc("id", "C301", "_version_", "301")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C302", "_version_", "302")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertU(commit());
        assertJQ(req("qt", "/get", "getVersions", "2"), "=={'versions':[302,301]}");
        assertJQ(req("q", "*:*", "sort", "_version_ desc", "fl", "id,_version_", "rows", "2"), "/response/docs==[" + "{'id':'C302','_version_':302}" + ",{'id':'C301','_version_':301}" + "]");
        updateJ(jsonAdd(sdoc("id", "C2", "_version_", "302")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // leave each test method in a good state
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

83. TestRecoveryHdfs#testBuffering()

Project: lucene-solr
File: TestRecoveryHdfs.java
@Test
public void testBuffering() throws Exception {
    DirectUpdateHandler2.commitOnClose = false;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = logReplayFinish::release;
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    try {
        clearIndex();
        assertU(commit());
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        Future<UpdateLog.RecoveryInfo> rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture == null);
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        // simulate updates from a leader
        updateJ(jsonAdd(sdoc("id", "B1", "_version_", "1010")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B11", "_version_", "1015")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonDelQ("id:B1 id:B11 id:B2 id:B3"), params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-1017"));
        updateJ(jsonAdd(sdoc("id", "B2", "_version_", "1020")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B3", "_version_", "1030")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        deleteAndGetVersion("B1", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-2010"));
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");
        assertU(commit());
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");
        // updates should be buffered, so we should not see any results yet.
        assertJQ(req("q", "*:*"), "/response/numFound==0");
        // real-time get should also not show anything (this could change in the future,
        // but it's currently used for validating version numbers too, so it would
        // be bad for updates to be visible if we're just buffering.
        assertJQ(req("qt", "/get", "id", "B3"), "=={'doc':null}");
        rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture != null);
        assertEquals(UpdateLog.State.APPLYING_BUFFERED, ulog.getState());
        logReplay.release(1000);
        UpdateLog.RecoveryInfo rinfo = rinfoFuture.get();
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");
        assertJQ(req("q", "*:*"), "/response/numFound==2");
        // move back to recovering
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        Long ver = getVer(req("qt", "/get", "id", "B3"));
        assertEquals(1030L, ver.longValue());
        // add a reordered doc that shouldn't overwrite one in the index
        updateJ(jsonAdd(sdoc("id", "B3", "_version_", "3")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // reorder two buffered updates
        updateJ(jsonAdd(sdoc("id", "B4", "_version_", "1040")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // this update should not take affect
        deleteAndGetVersion("B4", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-940"));
        updateJ(jsonAdd(sdoc("id", "B6", "_version_", "1060")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B5", "_version_", "1050")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B8", "_version_", "1080")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // test that delete by query is at least buffered along with everything else so it will delete the
        // currently buffered id:8 (even if it doesn't currently support versioning)
        updateJ("{\"delete\": { \"query\":\"id:B2 OR id:B8\" }}", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-3000"));
        assertJQ(req("qt", "/get", "getVersions", "13"), // the "3" appears because versions aren't checked while buffering
        "=={'versions':[-3000,1080,1050,1060,-940,1040,3,-2010,1030,1020,-1017,1015,1010]}");
        logReplay.drainPermits();
        rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture != null);
        assertEquals(UpdateLog.State.APPLYING_BUFFERED, ulog.getState());
        // apply a single update
        logReplay.release(1);
        // now add another update
        updateJ(jsonAdd(sdoc("id", "B7", "_version_", "1070")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // a reordered update that should be dropped
        deleteAndGetVersion("B5", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-950"));
        deleteAndGetVersion("B6", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-2060"));
        logReplay.release(1000);
        UpdateLog.RecoveryInfo recInfo = rinfoFuture.get();
        assertJQ(req("q", "*:*", "sort", "id asc", "fl", "id,_version_"), "/response/docs==[" + "{'id':'B3','_version_':1030}" + ",{'id':'B4','_version_':1040}" + ",{'id':'B5','_version_':1050}" + ",{'id':'B7','_version_':1070}" + "]");
        assertEquals(1, recInfo.deleteByQuery);
        // leave each test method in a good state
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

84. TestRecovery#testCleanShutdown()

Project: lucene-solr
File: TestRecovery.java
// make sure that log isn't needlessly replayed after a clean close
@Test
public void testCleanShutdown() throws Exception {
    DirectUpdateHandler2.commitOnClose = true;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = () -> logReplayFinish.release();
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    try {
        clearIndex();
        assertU(commit());
        assertU(adoc("id", "E1", "val_i", "1"));
        assertU(adoc("id", "E2", "val_i", "1"));
        // set to a high enough number so this test won't hang on a bug
        logReplay.release(10);
        h.close();
        createCore();
        // make sure the docs got committed
        assertJQ(req("q", "*:*"), "/response/numFound==2");
        // make sure no replay happened
        assertEquals(10, logReplay.availablePermits());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

85. TestRecovery#testBufferedMultipleCalls()

Project: lucene-solr
File: TestRecovery.java
@Test
public void testBufferedMultipleCalls() throws Exception {
    DirectUpdateHandler2.commitOnClose = false;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = () -> logReplayFinish.release();
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    Future<UpdateLog.RecoveryInfo> rinfoFuture;
    try {
        clearIndex();
        assertU(commit());
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        // simulate updates from a leader
        updateJ(jsonAdd(sdoc("id", "c1", "_version_", "101")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "c2", "_version_", "102")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "c3", "_version_", "103")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // call bufferUpdates again (this currently happens when recovery fails)... we should get a new starting point
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        updateJ(jsonAdd(sdoc("id", "c4", "_version_", "104")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "c5", "_version_", "105")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        logReplay.release(1000);
        rinfoFuture = ulog.applyBufferedUpdates();
        UpdateLog.RecoveryInfo rinfo = rinfoFuture.get();
        assertEquals(2, rinfo.adds);
        assertJQ(req("qt", "/get", "getVersions", "2"), "=={'versions':[105,104]}");
        // this time add some docs first before buffering starts (so tlog won't be at pos 0)
        updateJ(jsonAdd(sdoc("id", "c100", "_version_", "200")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "c101", "_version_", "201")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "c103", "_version_", "203")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "c104", "_version_", "204")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // call bufferUpdates again (this currently happens when recovery fails)... we should get a new starting point
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "c105", "_version_", "205")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "c106", "_version_", "206")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        rinfoFuture = ulog.applyBufferedUpdates();
        rinfo = rinfoFuture.get();
        assertEquals(2, rinfo.adds);
        assertJQ(req("q", "*:*", "sort", "_version_ asc", "fl", "id,_version_"), "/response/docs==[" + "{'id':'c4','_version_':104}" + ",{'id':'c5','_version_':105}" + ",{'id':'c100','_version_':200}" + ",{'id':'c101','_version_':201}" + ",{'id':'c105','_version_':205}" + ",{'id':'c106','_version_':206}" + "]");
        // The updates that were buffered (but never applied) still appear in recent versions!
        // This is good for some uses, but may not be good for others.
        assertJQ(req("qt", "/get", "getVersions", "11"), "=={'versions':[206,205,204,203,201,200,105,104,103,102,101]}");
        // leave each test method in a good state
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

86. TestRecovery#testDropBuffered()

Project: lucene-solr
File: TestRecovery.java
@Test
public void testDropBuffered() throws Exception {
    DirectUpdateHandler2.commitOnClose = false;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = () -> logReplayFinish.release();
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    try {
        clearIndex();
        assertU(commit());
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        Future<UpdateLog.RecoveryInfo> rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture == null);
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        // simulate updates from a leader
        updateJ(jsonAdd(sdoc("id", "C1", "_version_", "101")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C2", "_version_", "102")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C3", "_version_", "103")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertTrue(ulog.dropBufferedUpdates());
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "C4", "_version_", "104")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C5", "_version_", "105")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        logReplay.release(1000);
        rinfoFuture = ulog.applyBufferedUpdates();
        UpdateLog.RecoveryInfo rinfo = rinfoFuture.get();
        assertEquals(2, rinfo.adds);
        assertJQ(req("qt", "/get", "getVersions", "2"), "=={'versions':[105,104]}");
        // this time add some docs first before buffering starts (so tlog won't be at pos 0)
        updateJ(jsonAdd(sdoc("id", "C100", "_version_", "200")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C101", "_version_", "201")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "C103", "_version_", "203")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C104", "_version_", "204")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertTrue(ulog.dropBufferedUpdates());
        ulog.bufferUpdates();
        updateJ(jsonAdd(sdoc("id", "C105", "_version_", "205")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C106", "_version_", "206")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        rinfoFuture = ulog.applyBufferedUpdates();
        rinfo = rinfoFuture.get();
        assertEquals(2, rinfo.adds);
        assertJQ(req("q", "*:*", "sort", "_version_ asc", "fl", "id,_version_"), "/response/docs==[" + "{'id':'C4','_version_':104}" + ",{'id':'C5','_version_':105}" + ",{'id':'C100','_version_':200}" + ",{'id':'C101','_version_':201}" + ",{'id':'C105','_version_':205}" + ",{'id':'C106','_version_':206}" + "]");
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[206,205,201,200,105,104]}");
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        updateJ(jsonAdd(sdoc("id", "C301", "_version_", "998")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C302", "_version_", "999")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertTrue(ulog.dropBufferedUpdates());
        // make sure we can overwrite with a lower version
        // TODO: is this functionality needed?
        updateJ(jsonAdd(sdoc("id", "C301", "_version_", "301")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "C302", "_version_", "302")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        assertU(commit());
        assertJQ(req("qt", "/get", "getVersions", "2"), "=={'versions':[302,301]}");
        assertJQ(req("q", "*:*", "sort", "_version_ desc", "fl", "id,_version_", "rows", "2"), "/response/docs==[" + "{'id':'C302','_version_':302}" + ",{'id':'C301','_version_':301}" + "]");
        updateJ(jsonAdd(sdoc("id", "C2", "_version_", "302")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // leave each test method in a good state
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

87. TestRecovery#testBuffering()

Project: lucene-solr
File: TestRecovery.java
@Test
public void testBuffering() throws Exception {
    DirectUpdateHandler2.commitOnClose = false;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);
    UpdateLog.testing_logReplayHook = () -> {
        try {
            assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
    UpdateLog.testing_logReplayFinishHook = logReplayFinish::release;
    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();
    try {
        clearIndex();
        assertU(commit());
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        Future<UpdateLog.RecoveryInfo> rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture == null);
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        // simulate updates from a leader
        updateJ(jsonAdd(sdoc("id", "B1", "_version_", "1010")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B11", "_version_", "1015")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonDelQ("id:B1 id:B11 id:B2 id:B3"), params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-1017"));
        updateJ(jsonAdd(sdoc("id", "B2", "_version_", "1020")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B3", "_version_", "1030")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        deleteAndGetVersion("B1", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-2010"));
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");
        assertU(commit());
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");
        // updates should be buffered, so we should not see any results yet.
        assertJQ(req("q", "*:*"), "/response/numFound==0");
        // real-time get should also not show anything (this could change in the future,
        // but it's currently used for validating version numbers too, so it would
        // be bad for updates to be visible if we're just buffering.
        assertJQ(req("qt", "/get", "id", "B3"), "=={'doc':null}");
        rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture != null);
        assertEquals(UpdateLog.State.APPLYING_BUFFERED, ulog.getState());
        logReplay.release(1000);
        UpdateLog.RecoveryInfo rinfo = rinfoFuture.get();
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
        assertJQ(req("qt", "/get", "getVersions", "6"), "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");
        assertJQ(req("q", "*:*"), "/response/numFound==2");
        // move back to recovering
        ulog.bufferUpdates();
        assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
        Long ver = getVer(req("qt", "/get", "id", "B3"));
        assertEquals(1030L, ver.longValue());
        // add a reordered doc that shouldn't overwrite one in the index
        updateJ(jsonAdd(sdoc("id", "B3", "_version_", "3")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // reorder two buffered updates
        updateJ(jsonAdd(sdoc("id", "B4", "_version_", "1040")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // this update should not take affect
        deleteAndGetVersion("B4", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-940"));
        updateJ(jsonAdd(sdoc("id", "B6", "_version_", "1060")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B5", "_version_", "1050")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        updateJ(jsonAdd(sdoc("id", "B8", "_version_", "1080")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // test that delete by query is at least buffered along with everything else so it will delete the
        // currently buffered id:8 (even if it doesn't currently support versioning)
        updateJ("{\"delete\": { \"query\":\"id:B2 OR id:B8\" }}", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-3000"));
        assertJQ(req("qt", "/get", "getVersions", "13"), // the "3" appears because versions aren't checked while buffering
        "=={'versions':[-3000,1080,1050,1060,-940,1040,3,-2010,1030,1020,-1017,1015,1010]}");
        logReplay.drainPermits();
        rinfoFuture = ulog.applyBufferedUpdates();
        assertTrue(rinfoFuture != null);
        assertEquals(UpdateLog.State.APPLYING_BUFFERED, ulog.getState());
        // apply a single update
        logReplay.release(1);
        // now add another update
        updateJ(jsonAdd(sdoc("id", "B7", "_version_", "1070")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
        // a reordered update that should be dropped
        deleteAndGetVersion("B5", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-950"));
        deleteAndGetVersion("B6", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-2060"));
        logReplay.release(1000);
        UpdateLog.RecoveryInfo recInfo = rinfoFuture.get();
        assertJQ(req("q", "*:*", "sort", "id asc", "fl", "id,_version_"), "/response/docs==[" + "{'id':'B3','_version_':1030}" + ",{'id':'B4','_version_':1040}" + ",{'id':'B5','_version_':1050}" + ",{'id':'B7','_version_':1070}" + "]");
        assertEquals(1, recInfo.deleteByQuery);
        // leave each test method in a good state
        assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
    } finally {
        DirectUpdateHandler2.commitOnClose = true;
        UpdateLog.testing_logReplayHook = null;
        UpdateLog.testing_logReplayFinishHook = null;
        req().close();
    }
}

88. QuorumTest#testNoLogBeforeLeaderEstablishment()

Project: zookeeper
File: QuorumTest.java
/**
     * Tests if closeSession can be logged before a leader gets established, which
     * could lead to a locked-out follower (see ZOOKEEPER-790). 
     * 
     * The test works as follows. It has a client connecting to a follower f and
     * sending batches of 1,000 updates. The goal is that f has a zxid higher than
     * all other servers in the initial leader election. This way we can crash and
     * recover the follower so that the follower believes it is the leader once it
     * recovers (LE optimization: once a server receives a message from all other 
     * servers, it picks a leader.
     * 
     * It also makes the session timeout very short so that we force the false 
     * leader to close the session and write it to the log in the buggy code (before 
     * ZOOKEEPER-790). Once f drops leadership and finds the current leader, its epoch
     * is higher, and it rejects the leader. Now, if we prevent the leader from closing
     * the session by only starting up (see Leader.lead()) once it obtains a quorum of 
     * supporters, then f will find the current leader and support it because it won't
     * have a highe epoch.
     * 
     */
@Test
public void testNoLogBeforeLeaderEstablishment() throws Exception {
    final Semaphore sem = new Semaphore(0);
    qu = new QuorumUtil(2, 10);
    qu.startQuorum();
    int index = 1;
    while (qu.getPeer(index).peer.leader == null) index++;
    Leader leader = qu.getPeer(index).peer.leader;
    Assert.assertNotNull(leader);
    /*
         * Reusing the index variable to select a follower to connect to
         */
    index = (index == 1) ? 2 : 1;
    ZooKeeper zk = new DisconnectableZooKeeper("127.0.0.1:" + qu.getPeer(index).peer.getClientPort(), ClientBase.CONNECTION_TIMEOUT, new Watcher() {

        public void process(WatchedEvent event) {
        }
    });
    zk.create("/blah", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    for (int i = 0; i < 50000; i++) {
        zk.setData("/blah", new byte[0], -1, new AsyncCallback.StatCallback() {

            public void processResult(int rc, String path, Object ctx, Stat stat) {
                counter++;
                if (rc != 0) {
                    errors++;
                }
                if (counter == 20000) {
                    sem.release();
                }
            }
        }, null);
        if (i == 5000) {
            qu.shutdown(index);
            LOG.info("Shutting down s1");
        }
        if (i == 12000) {
            qu.start(index);
            LOG.info("Setting up server: " + index);
        }
        if ((i % 1000) == 0) {
            Thread.sleep(500);
        }
    }
    // Wait until all updates return
    sem.tryAcquire(15, TimeUnit.SECONDS);
    // Verify that server is following and has the same epoch as the leader
    Assert.assertTrue("Not following", qu.getPeer(index).peer.follower != null);
    long epochF = (qu.getPeer(index).peer.getActiveServer().getZxid() >> 32L);
    long epochL = (leader.getEpoch() >> 32L);
    Assert.assertTrue("Zxid: " + qu.getPeer(index).peer.getActiveServer().getZxid() + "Current epoch: " + epochF, epochF == epochL);
    zk.close();
}

89. ZooKeeperServer#createSession()

Project: voltdb
File: ZooKeeperServer.java
void createSession(ServerCnxn cnxn, byte passwd[], int timeout) throws InterruptedException {
    Semaphore sessionIdCreated = m_callout.createSession(cnxn, passwd, timeout);
    sessionIdCreated.acquire();
}

90. TestZK#testLeaderFailoverHoles()

Project: voltdb
File: TestZK.java
@Test
public void testLeaderFailoverHoles() throws Exception {
    // as above but put multiple failed nodes between the new and previous?
    ZooKeeper zk0 = getClient(0);
    ZooKeeper zk1 = getClient(1);
    ZooKeeper zk2 = getClient(2);
    ZooKeeper zk3 = getClient(3);
    ZooKeeper zk4 = getClient(4);
    ZooKeeper zk5 = getClient(5);
    ZooKeeper zk6 = getClient(6);
    ZooKeeper zk7 = getClient(7);
    zk0.create("/election", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    final Semaphore sem1 = new Semaphore(0);
    LeaderNoticeHandler r1 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem1.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    final Semaphore sem7 = new Semaphore(0);
    LeaderNoticeHandler r7 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem7.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    LeaderElector elector0 = new LeaderElector(zk0, "/election", "node", new byte[0], null);
    LeaderElector elector1 = new LeaderElector(zk1, "/election", "node", new byte[0], r1);
    LeaderElector elector2 = new LeaderElector(zk2, "/election", "node", new byte[0], null);
    LeaderElector elector3 = new LeaderElector(zk3, "/election", "node", new byte[0], null);
    LeaderElector elector4 = new LeaderElector(zk4, "/election", "node", new byte[0], null);
    LeaderElector elector5 = new LeaderElector(zk5, "/election", "node", new byte[0], null);
    LeaderElector elector6 = new LeaderElector(zk6, "/election", "node", new byte[0], null);
    LeaderElector elector7 = new LeaderElector(zk7, "/election", "node", new byte[0], r7);
    elector0.start(true);
    elector1.start(true);
    elector2.start(true);
    elector3.start(true);
    elector4.start(true);
    elector5.start(true);
    elector6.start(true);
    elector7.start(true);
    assertTrue(elector0.isLeader());
    assertFalse(elector1.isLeader());
    assertFalse(elector2.isLeader());
    assertFalse(elector3.isLeader());
    assertFalse(elector4.isLeader());
    assertFalse(elector5.isLeader());
    assertFalse(elector6.isLeader());
    assertFalse(elector7.isLeader());
    // 4 should become the leader
    elector6.shutdown();
    zk6.close();
    elector4.shutdown();
    zk4.close();
    elector2.shutdown();
    zk2.close();
    elector0.shutdown();
    zk0.close();
    assertTrue(sem1.tryAcquire(5, TimeUnit.SECONDS));
    assertTrue(elector1.isLeader());
    assertFalse(elector3.isLeader());
    assertFalse(elector5.isLeader());
    assertFalse(elector7.isLeader());
    elector5.shutdown();
    zk5.close();
    elector3.shutdown();
    zk3.close();
    elector1.shutdown();
    zk1.close();
    assertTrue(sem7.tryAcquire(5, TimeUnit.SECONDS));
    assertTrue(elector7.isLeader());
    // cleanup.
    elector7.shutdown();
    zk7.close();
}

91. TestZK#testLeaderFailover()

Project: voltdb
File: TestZK.java
@Test
public void testLeaderFailover() throws Exception {
    ZooKeeper zk = getClient(0);
    ZooKeeper zk2 = getClient(1);
    ZooKeeper zk3 = getClient(2);
    zk.create("/election", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    final Semaphore sem2 = new Semaphore(0);
    LeaderNoticeHandler r2 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem2.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    final Semaphore sem3 = new Semaphore(0);
    LeaderNoticeHandler r3 = new LeaderNoticeHandler() {

        @Override
        public void becomeLeader() {
            sem3.release();
        }

        @Override
        public void noticedTopologyChange(boolean added, boolean removed) {
        }
    };
    LeaderElector elector1 = new LeaderElector(zk, "/election", "node", new byte[0], null);
    LeaderElector elector2 = new LeaderElector(zk2, "/election", "node", new byte[0], r2);
    LeaderElector elector3 = new LeaderElector(zk3, "/election", "node", new byte[0], r3);
    elector1.start(true);
    elector2.start(true);
    elector3.start(true);
    assertTrue(elector1.isLeader());
    assertFalse(elector2.isLeader());
    assertFalse(elector3.isLeader());
    // 2 should become the leader
    elector1.shutdown();
    zk.close();
    assertTrue(sem2.tryAcquire(5, TimeUnit.SECONDS));
    assertTrue(elector2.isLeader());
    assertEquals(0, sem3.availablePermits());
    // 3 should become the leader now
    elector2.shutdown();
    zk2.close();
    assertTrue(sem3.tryAcquire(5, TimeUnit.SECONDS));
    assertTrue(elector3.isLeader());
    elector3.shutdown();
    zk3.close();
}

92. QueryTest#testValidationConcurrencyWithSharedState()

Project: squidb
File: QueryTest.java
public void testValidationConcurrencyWithSharedState() {
    // If the code to compile queries with extra parentheses for validation isn't threadsafe,
    // one of these should throw a SQL parsing exception. If the test passes, all is well
    final AtomicBoolean compiledOnce = new AtomicBoolean(false);
    final Semaphore blockCriterion = new Semaphore(0);
    final Semaphore blockThread = new Semaphore(0);
    Criterion weirdCriterion = new BinaryCriterion(Thing.BAR, Operator.eq, 0) {

        @Override
        protected void populate(SqlBuilder builder, boolean forSqlValidation) {
            super.populate(builder, forSqlValidation);
            if (compiledOnce.compareAndSet(false, true)) {
                try {
                    blockThread.release();
                    blockCriterion.acquire();
                } catch (InterruptedException e) {
                    fail("InterruptedException");
                }
            }
        }
    };
    Query subquery = Query.select(Thing.FOO).from(Thing.TABLE).where(weirdCriterion);
    final SubqueryTable subqueryTable = subquery.as("t1");
    Query query = Query.select().from(subqueryTable);
    query.requestValidation();
    Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                blockThread.acquire();
                Query query2 = Query.select().from(subqueryTable);
                query2.requestValidation();
                SquidCursor<Thing> cursor = database.query(Thing.class, query2);
                cursor.close();
                blockCriterion.release();
            } catch (InterruptedException e) {
                fail("InterruptedException");
            }
        }
    });
    t.start();
    SquidCursor<Thing> cursor = database.query(Thing.class, query);
    cursor.close();
    try {
        t.join();
    } catch (InterruptedException e) {
        fail("InterruptedException");
    }
}

93. SquidDatabaseTest#testConcurrentReadsWithWAL()

Project: squidb
File: SquidDatabaseTest.java
public void testConcurrentReadsWithWAL() {
    // Tests that concurrent reads can happen when using WAL, but only committed changes will be visible
    // on other threads
    insertBasicTestModel();
    final Semaphore sema1 = new Semaphore(0);
    final Semaphore sema2 = new Semaphore(0);
    final AtomicInteger countBeforeCommit = new AtomicInteger();
    final AtomicInteger countAfterCommit = new AtomicInteger();
    Thread thread = new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                sema2.acquire();
            } catch (InterruptedException e) {
                fail(e.getMessage());
            }
            countBeforeCommit.set(database.countAll(TestModel.class));
            sema1.release();
            try {
                sema2.acquire();
            } catch (InterruptedException e) {
                fail(e.getMessage());
            }
            countAfterCommit.set(database.countAll(TestModel.class));
        }
    });
    database.beginTransactionNonExclusive();
    try {
        thread.start();
        insertBasicTestModel("A", "B", System.currentTimeMillis() + 100);
        sema2.release();
        try {
            sema1.acquire();
        } catch (InterruptedException e) {
            fail(e.getMessage());
        }
        database.setTransactionSuccessful();
    } finally {
        database.endTransaction();
        sema2.release();
    }
    try {
        thread.join();
    } catch (InterruptedException e) {
        fail(e.getMessage());
    }
    assertEquals(1, countBeforeCommit.get());
    assertEquals(2, countAfterCommit.get());
}

94. LocalMergeResults#reset()

Project: squall
File: LocalMergeResults.java
public static void reset() {
    _collectedLastComponents = 0;
    _numTuplesProcessed = 0;
    _computedAgg = null;
    _fileAgg = null;
    _semFullResult = new Semaphore(1, true);
    _semNumResults = new Semaphore(0, true);
}

95. RtpSocket#resetFifo()

Project: spydroid-ipcamera
File: RtpSocket.java
private void resetFifo() {
    mCount = 0;
    mBufferIn = 0;
    mBufferOut = 0;
    mTimestamps = new long[mBufferCount];
    mBufferRequested = new Semaphore(mBufferCount);
    mBufferCommitted = new Semaphore(0);
    mReport.reset();
    mAverageBitrate.reset();
}

96. FluxTests#multiplexUsingProcessors()

Project: reactor-core
File: FluxTests.java
@Test(timeout = TIMEOUT)
public void multiplexUsingProcessors() throws Exception {
    final Flux<Integer> forkStream = Flux.just(1, 2, 3).log("begin-computation");
    final Flux<Integer> forkStream2 = Flux.just(1, 2, 3).log("begin-persistence");
    final TopicProcessor<Integer> computationEmitterProcessor = TopicProcessor.create("computation", BACKLOG);
    final Flux<String> computationStream = computationEmitterProcessor.map( i -> Integer.toString(i));
    final TopicProcessor<Integer> persistenceEmitterProcessor = TopicProcessor.create("persistence", BACKLOG);
    final Flux<String> persistenceStream = persistenceEmitterProcessor.map( i -> "done " + i);
    forkStream.subscribe(computationEmitterProcessor);
    forkStream2.subscribe(persistenceEmitterProcessor);
    final Semaphore doneSemaphore = new Semaphore(0);
    final Flux<List<String>> joinStream = Flux.zip(computationStream.log("log1"), persistenceStream.log("log2"), ( a,  b) -> Arrays.asList(a, b));
    // Method chaining doesn't compile.
    joinStream.log("log-final").subscribe( list -> println("Joined: ", list),  t -> println("Join failed: ", t.getMessage()), () -> {
        println("Join complete.");
        doneSemaphore.release();
    });
    doneSemaphore.acquire();
}

97. ConcurrencyTest#testConcurrentEvaluationWithDifferingLocals()

Project: pebble
File: ConcurrencyTest.java
/**
     * Issue #40
     *
     * @throws InterruptedException
     * @throws PebbleException
     */
@Test
public void testConcurrentEvaluationWithDifferingLocals() throws InterruptedException, PebbleException {
    final PebbleEngine engine = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false).build();
    String templateSource = "{{ 2000.234 | numberformat }}";
    final PebbleTemplate template = engine.getTemplate(templateSource);
    ExecutorService es = Executors.newCachedThreadPool();
    final AtomicInteger totalFailed = new AtomicInteger();
    int numOfConcurrentEvaluations = Math.min(4, Runtime.getRuntime().availableProcessors());
    final Semaphore semaphore = new Semaphore(numOfConcurrentEvaluations);
    final String germanResult = "2.000,234";
    final String canadianResult = "2,000.234";
    for (int i = 0; i < 1000; i++) {
        semaphore.acquire();
        es.submit(new Runnable() {

            @Override
            public void run() {
                try {
                    final boolean isGerman = r.nextBoolean();
                    final Locale locale = isGerman ? Locale.GERMANY : Locale.CANADA;
                    final StringWriter writer = new StringWriter();
                    template.evaluate(writer, locale);
                    final String expectedResult = isGerman ? germanResult : canadianResult;
                    final String actualResult = writer.toString();
                    if (!expectedResult.equals(actualResult)) {
                        System.out.println(String.format("Locale: %s\nExpected: %s\nActual: %s\n", locale.toString(), expectedResult, actualResult));
                        totalFailed.incrementAndGet();
                    }
                } catch (IOExceptionPebbleException |  e) {
                    e.printStackTrace();
                    totalFailed.incrementAndGet();
                } finally {
                    semaphore.release();
                }
            }
        });
        if (totalFailed.intValue() > 0) {
            break;
        }
    }
    // Wait for them all to complete
    semaphore.acquire(numOfConcurrentEvaluations);
    es.shutdown();
    assertEquals(0, totalFailed.intValue());
}

98. ConcurrencyTest#testThreadSafeCompilationOfMultipleTemplates()

Project: pebble
File: ConcurrencyTest.java
/**
     * True concurrent compilation is not currently supported. The pebble engine
     * will only compile one at a time. This test simply makes sure that if a
     * user attempts to trigger concurrent compilation everything still succeeds
     * (despite it being executed one at a time behind the scenes).
     *
     * @throws InterruptedException
     * @throws PebbleException
     */
@Test
public void testThreadSafeCompilationOfMultipleTemplates() throws InterruptedException, PebbleException {
    final PebbleEngine engine = new PebbleEngine.Builder().templateCache(null).strictVariables(false).build();
    final ExecutorService es = Executors.newCachedThreadPool();
    final AtomicInteger totalFailed = new AtomicInteger();
    int numOfConcurrentEvaluations = Math.min(4, Runtime.getRuntime().availableProcessors());
    final Semaphore semaphore = new Semaphore(numOfConcurrentEvaluations);
    for (int i = 0; i < 1000; i++) {
        semaphore.acquire(1);
        es.submit(new Runnable() {

            @Override
            public void run() {
                try {
                    PebbleTemplate template = engine.getTemplate("templates/template.concurrent1.peb");
                    int a = r.nextInt();
                    int b = r.nextInt();
                    int c = r.nextInt();
                    int d = r.nextInt();
                    TestObject testObject = new TestObject(a, b, c, "test" + d);
                    StringWriter writer = new StringWriter();
                    Map<String, Object> context = new HashMap<>();
                    context.put("test", testObject);
                    template.evaluate(writer, context);
                    String expectedResult = new StringBuilder().append(a).append(":").append(b).append(":").append(c).toString();
                    String actualResult = writer.toString();
                    if (!expectedResult.equals(actualResult)) {
                        System.out.println("Expected1: " + expectedResult);
                        System.out.println("Actual1: " + actualResult);
                        totalFailed.incrementAndGet();
                    }
                } catch (IOExceptionPebbleException |  e) {
                    e.printStackTrace();
                    totalFailed.incrementAndGet();
                } finally {
                    semaphore.release();
                }
            }
        });
        es.submit(new Runnable() {

            @Override
            public void run() {
                try {
                    PebbleTemplate template = engine.getTemplate("templates/template.concurrent2.peb");
                    int a = r.nextInt();
                    int b = r.nextInt();
                    int c = r.nextInt();
                    int d = r.nextInt();
                    TestObject testObject = new TestObject(a, b, c, "test" + d);
                    StringWriter writer = new StringWriter();
                    Map<String, Object> context = new HashMap<>();
                    context.put("test", testObject);
                    template.evaluate(writer, context);
                    String expectedResult = new StringBuilder().append(a).append(":").append(b).append(":").append(c).toString();
                    String actualResult = writer.toString();
                    if (!expectedResult.equals(actualResult)) {
                        System.out.println("Expected2: " + expectedResult);
                        System.out.println("Actual2: " + actualResult);
                        totalFailed.incrementAndGet();
                    }
                } catch (IOExceptionPebbleException |  e) {
                    e.printStackTrace();
                    totalFailed.incrementAndGet();
                } finally {
                    semaphore.release();
                }
            }
        });
        if (totalFailed.intValue() > 0) {
            break;
        }
    }
    // Wait for them all to complete
    semaphore.acquire(numOfConcurrentEvaluations);
    es.shutdown();
    assertEquals(0, totalFailed.intValue());
}

99. ConcurrencyTest#testConcurrentEvaluation()

Project: pebble
File: ConcurrencyTest.java
@Test
public void testConcurrentEvaluation() throws InterruptedException, PebbleException {
    PebbleEngine engine = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false).build();
    String templateSource = "{{ test.a }}:{{ test.b }}:{{ test.c }}:{{ test.d | upper }}";
    final PebbleTemplate template = engine.getTemplate(templateSource);
    ExecutorService es = Executors.newCachedThreadPool();
    final AtomicInteger totalFailed = new AtomicInteger();
    int numOfConcurrentEvaluations = Math.min(4, Runtime.getRuntime().availableProcessors());
    final Semaphore semaphore = new Semaphore(numOfConcurrentEvaluations);
    for (int i = 0; i < 10000; i++) {
        semaphore.acquire();
        es.submit(new Runnable() {

            @Override
            public void run() {
                try {
                    int a = r.nextInt();
                    int b = r.nextInt();
                    int c = r.nextInt();
                    int d = r.nextInt();
                    TestObject testObject = new TestObject(a, b, c, "test" + d);
                    StringWriter writer = new StringWriter();
                    Map<String, Object> context = new HashMap<>();
                    context.put("test", testObject);
                    template.evaluate(writer, context);
                    String expectedResult = new StringBuilder().append(a).append(":").append(b).append(":").append(c).append(":").append("TEST").append(d).toString();
                    String actualResult = writer.toString();
                    if (!expectedResult.equals(actualResult)) {
                        System.out.println("Expected: " + expectedResult);
                        System.out.println("Actual: " + actualResult);
                        System.out.println("");
                        totalFailed.incrementAndGet();
                    }
                } catch (IOExceptionPebbleException |  e) {
                    e.printStackTrace();
                    totalFailed.incrementAndGet();
                } finally {
                    semaphore.release();
                }
            }
        });
        if (totalFailed.intValue() > 0) {
            break;
        }
    }
    // Wait for them all to complete
    semaphore.acquire(numOfConcurrentEvaluations);
    es.shutdown();
    assertEquals(0, totalFailed.intValue());
}

100. CacheTest#testConcurrentCacheHitting()

Project: pebble
File: CacheTest.java
@Test
public void testConcurrentCacheHitting() throws InterruptedException, PebbleException {
    final PebbleEngine engine = new PebbleEngine.Builder().strictVariables(false).build();
    final ExecutorService es = Executors.newCachedThreadPool();
    final AtomicInteger totalFailed = new AtomicInteger();
    int numOfConcurrentThreads = Math.min(4, Runtime.getRuntime().availableProcessors());
    final Semaphore semaphore = new Semaphore(numOfConcurrentThreads);
    for (int i = 0; i < 100000; i++) {
        semaphore.acquire();
        es.submit(new Runnable() {

            @Override
            public void run() {
                try {
                    PebbleTemplate template = engine.getTemplate("templates/template.concurrent1.peb");
                    int a = r.nextInt();
                    int b = r.nextInt();
                    int c = r.nextInt();
                    TestObject testObject = new TestObject(a, b, c);
                    StringWriter writer = new StringWriter();
                    Map<String, Object> context = new HashMap<>();
                    context.put("test", testObject);
                    template.evaluate(writer, context);
                    String expectedResult = new StringBuilder().append(a).append(":").append(b).append(":").append(c).toString();
                    String actualResult = writer.toString();
                    if (!expectedResult.equals(actualResult)) {
                        System.out.println("Expected: " + expectedResult);
                        System.out.println("Actual: " + actualResult);
                        totalFailed.incrementAndGet();
                    }
                } catch (IOExceptionPebbleException |  e) {
                    e.printStackTrace();
                    totalFailed.incrementAndGet();
                } finally {
                    semaphore.release();
                }
            }
        });
        // quick fail
        if (totalFailed.intValue() > 0) {
            break;
        }
    }
    // Wait for them all to complete
    semaphore.acquire(numOfConcurrentThreads);
    es.shutdown();
    assertEquals(0, totalFailed.intValue());
}