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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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()); }