/** * Runs all runnable tasks (pending and future) that have been queued on the UI thread. Such tasks may be queued by * e.g. {@link android.app.Activity#runOnUiThread(Runnable)} or {@link android.os.AsyncTask#onPostExecute(Object)}. * * **Note:** calling this method does not pause or un-pause the scheduler, however the clock is advanced as * future tasks are run. * * @see #runUiThreadTasks */ public static void runUiThreadTasksIncludingDelayedTasks() { getShadowMainLooper().runToEndOfTasks(); }
@Override public void run() { // "Commit" layout (it will fail since it doesn't have compatible size specs) mLayoutThreadShadowLooper.runToEndOfTasks(); } });
@Override public void run() { mLayoutThreadShadowLooper.runToEndOfTasks(); } });
private void waitForLatch(CountDownLatch latch) { try { latch.await(10, TimeUnit.SECONDS); } catch (InterruptedException e) { throw new RuntimeException(e); } ShadowLooper.getShadowMainLooper().runToEndOfTasks(); }
@NonNull @Override public Object apply(@NonNull Object input) { // Sneak in a deactivation here to test cancellation mid-flow. updatable.removeFromObservables(); looper.runToEndOfTasks(); return input; } };
@After public void tearDown() { // If a test fails, make sure the shadow looper gets cleared out anyway so it doesn't impact // other tests. mChangeSetThreadShadowLooper.runToEndOfTasks(); }
@After public void tearDown() { Util.setSdkVersionInt(initialSdkVersion); Shadows.shadowOf(Looper.getMainLooper()).runToEndOfTasks(); assertThat(retriever.pendingRequestManagerFragments).isEmpty(); assertThat(retriever.pendingSupportRequestManagerFragments).isEmpty(); }
private void retriggerUpdate() { updatable.resetUpdated(); updateDispatcher.update(); looper.runToEndOfTasks(); }
@Test public void shouldCallLastRemovedOnceOnlyForUpdateDispatcher() { updatable.addToObservable(updateDispatcherWithUpdatablesChanged); secondUpdatable.addToObservable(updateDispatcherWithUpdatablesChanged); updatable.removeFromObservables(); looper.runToEndOfTasks(); secondUpdatable.removeFromObservables(); looper.runToEndOfTasks(); verify(mockActivationHandler).observableActivated(updateDispatcherWithUpdatablesChanged); }
@Test public void testCreatesNewFragmentIfNoneExists() { for (RetrieverHarness harness : harnesses) { harness.doGet(); Shadows.shadowOf(Looper.getMainLooper()).runToEndOfTasks(); assertTrue(harness.hasFragmentWithTag(RequestManagerRetriever.FRAGMENT_TAG)); } }
@Test public void testListenerInvokedOnlyOnceForMultipleSetRootAsync() { mComponentTree.setNewLayoutStateReadyListener(mListener); mComponentTree.setSizeSpecAsync(mWidthSpec, mHeightSpec); mComponentTree.setSizeSpecAsync(mWidthSpec2, mHeightSpec2); verify(mListener, never()).onNewLayoutStateReady(any(ComponentTree.class)); // Now the background thread run the queued task. mLayoutThreadShadowLooper.runToEndOfTasks(); verify(mListener).onNewLayoutStateReady(mComponentTree); }
@Test public void testListenerInvokedForSetRootAsyncWhenAttached() { mComponentTree.setNewLayoutStateReadyListener(mListener); mComponentTree.setSizeSpecAsync(mWidthSpec, mHeightSpec); mComponentTree.setLithoView(new LithoView(mContext)); mComponentTree.attach(); verify(mListener, never()).onNewLayoutStateReady(any(ComponentTree.class)); // Now the background thread run the queued task. mLayoutThreadShadowLooper.runToEndOfTasks(); verify(mListener).onNewLayoutStateReady(mComponentTree); }
@Test public void testKeepUpdatedStateValue() { mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); TestStateContainer previousStateContainer = (TestStateContainer) getStateContainersMap().get(mTestComponent.getGlobalKey()); assertThat(previousStateContainer).isNotNull(); assertThat(previousStateContainer.mCount).isEqualTo(INITIAL_COUNT_STATE_VALUE + 1); }
@Test public void testTransferAndUpdateState() { mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); assertThat(mTestComponent.getComponentForStateUpdate().getCount()).isEqualTo(INITIAL_COUNT_STATE_VALUE + 2); }
@Test public void testHasCompletedLatestLayoutForAsyncRender() { ComponentTreeHolder holder = createComponentTreeHolder(mComponentRenderInfo); holder.computeLayoutAsync(mContext, mWidthSpec, mHeightSpec); assertThat(holder.hasCompletedLatestLayout()).isFalse(); mLayoutThreadShadowLooper.runToEndOfTasks(); assertThat(holder.hasCompletedLatestLayout()).isTrue(); // Re-computing with the same async layout specs shouldn't invalidate the layout holder.computeLayoutAsync(mContext, mWidthSpec, mHeightSpec); assertThat(holder.hasCompletedLatestLayout()).isTrue(); }
@Test public void testStateStatsTest() { final long before = LithoStats.getStateUpdates(); mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); final long after = LithoStats.getStateUpdates(); assertThat(after - before).isEqualTo(1); }
@Test public void testSyncStateStatsWhenAsyncTest() { final long before = LithoStats.getStateUpdatesSync(); mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); final long after = LithoStats.getStateUpdatesSync(); assertThat(after - before).isEqualTo(0); }
@Test public void testSyncStateStatsWhenSyncTest() { final long before = LithoStats.getStateUpdatesSync(); mComponentTree.updateStateSync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); final long after = LithoStats.getStateUpdatesSync(); assertThat(after - before).isEqualTo(1); }
@Test public void testTransferState() { mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); mLayoutThreadShadowLooper.runToEndOfTasks(); mComponentTree.setSizeSpec(mWidthSpec, mHeightSpec); assertThat(mTestComponent.getComponentForStateUpdate().getCount()).isEqualTo(INITIAL_COUNT_STATE_VALUE + 1); }
@Test public void testClearAppliedStateUpdates() { mComponentTree.updateStateAsync(mTestComponent.getGlobalKey(), new TestStateUpdate(), "test"); assertThat(getPendingStateUpdatesForComponent(mTestComponent)).hasSize(1); mLayoutThreadShadowLooper.runToEndOfTasks(); assertThat(getPendingStateUpdatesForComponent(mTestComponent.getComponentForStateUpdate())).isNull(); }