@Override public MultisetSubject named(String format, Object... args) { super.named(format, args); return this; }
@Override public SortedSetSubject named(String format, Object... args) { super.named(format, args); return this; }
.isEqualTo(expectedChanged); assertThat(toTest) .named(format, iterableToAdd, index) .containsExactlyElementsIn(expected.get(i));
public void testCombinations() { ImmutableList<Set<Integer>> sampleSets = ImmutableList.<Set<Integer>>of( ImmutableSet.<Integer>of(), ImmutableSet.of(1, 2), ImmutableSet.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); for (Set<Integer> sampleSet : sampleSets) { for (int k = 0; k <= sampleSet.size(); k++) { final int size = k; Set<Set<Integer>> expected = Sets.filter( Sets.powerSet(sampleSet), new Predicate<Set<Integer>>() { @Override public boolean apply(Set<Integer> input) { return input.size() == size; } }); assertThat(Sets.combinations(sampleSet, k)) .named("Sets.combinations(%s, %s)", sampleSet, k) .containsExactlyElementsIn(expected) .inOrder(); } } }
private final IterableSubject delegate() { IterableSubject delegate = check().that(actual()); if (internalCustomName() != null) { delegate = delegate.named(internalCustomName()); } return delegate; }
@Test public void shouldSetWhenOnMessage() throws Exception { final List<Long> whens = new ArrayList<>(); Handler h = new Handler(new Handler.Callback() { @Override public boolean handleMessage(Message msg) { whens.add(msg.getWhen()); return false; } }); final long startTime = Robolectric.getForegroundThreadScheduler().getCurrentTime(); h.sendEmptyMessage(0); h.sendEmptyMessageDelayed(0, 4000L); Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable(); h.sendEmptyMessageDelayed(0, 12000L); Robolectric.getForegroundThreadScheduler().advanceToLastPostedRunnable(); assertThat(whens).named("whens").containsExactly(startTime, startTime + 4000, startTime + 16000); }
@Test public void postAndRemoveSyncBarrierToken_syncBefore() { int token = postSyncBarrier(queue); enqueueMessage(testMessage, SystemClock.uptimeMillis()); scheduler.advanceToLastPostedRunnable(); removeSyncBarrier(queue, token); assertThat(shadowQueue.getHead()).isNull(); assertThat(handler.handled).named("handled:after").containsExactly(testMessage); }
@Test public void postAndRemoveSyncBarrierToken_messageBeforeConsumed() { enqueueMessage(testMessage, SystemClock.uptimeMillis()); int token = postSyncBarrier(queue); scheduler.advanceToLastPostedRunnable(); removeSyncBarrier(queue, token); assertThat(shadowQueue.getHead()).isNull(); assertThat(handler.handled).named("handled:after").containsExactly(testMessage); }
@Test public void postAndRemoveSyncBarrierToken_messageAfter() { enqueueMessage(testMessage, SystemClock.uptimeMillis() + 100); int token = postSyncBarrier(queue); removeSyncBarrier(queue, token); assertThat(shadowQueue.getHead()).isEqualTo(testMessage); scheduler.advanceToLastPostedRunnable(); assertThat(shadowQueue.getHead()).isNull(); assertThat(handler.handled).named("handled:after").containsExactly(testMessage); }
@Test public void enqueueMessage_withZeroWhen_postsAtFront() { enqueueMessage(testMessage, 0); Message m2 = handler.obtainMessage(2); enqueueMessage(m2, 0); scheduler.advanceToLastPostedRunnable(); assertThat(handler.handled).named("handled").containsExactly(m2, testMessage); }
@Test public void nestedPostAtFront_whileUnpaused_runsAfter() { final List<Integer> order = new ArrayList<>(); scheduler.unPause(); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(1); scheduler.postAtFrontOfQueue(new Runnable() { @Override public void run() { order.add(3); } }); order.add(2); } }, 0); assertThat(order).named("order").containsExactly(1, 2, 3); assertThat(scheduler.size()).named("size").isEqualTo(0); }
@Test public void scheduler_wontDispatchRemovedMessage_evenIfMessageReused() { final ArrayList<Long> runAt = new ArrayList<>(); ShadowLooper.pauseMainLooper(); Handler handler = new Handler() { @Override public void handleMessage(Message msg) { runAt.add(shadowOf(Looper.myLooper()).getScheduler().getCurrentTime()); } }; final long startTime = Robolectric.getForegroundThreadScheduler().getCurrentTime(); Message msg = handler.obtainMessage(123); handler.sendMessageDelayed(msg, 200); handler.removeMessages(123); Message newMsg = handler.obtainMessage(123); assertThat(newMsg).named("new message").isSameAs(msg); handler.sendMessageDelayed(newMsg, 400); ShadowLooper.runUiThreadTasksIncludingDelayedTasks(); // Original implementation had a bug which caused reused messages to still // be invoked at their original post time. assertThat(runAt).named("handledAt").containsExactly(startTime + 400L); }
@Test public void nestedPost_whileUnpaused_automaticallyExecutes3After() { final List<Integer> order = new ArrayList<>(); scheduler.unPause(); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(1); scheduler.post(new Runnable() { @Override public void run() { order.add(3); } }); order.add(2); } }, 0); assertThat(order).named("order").containsExactly(1, 2, 3); assertThat(scheduler.size()).named("size").isEqualTo(0); }
assertThat(events).named("start").isEmpty(); Scheduler s = ShadowLooper.getShadowMainLooper().getScheduler(); assertThat(s).isSameAs(RuntimeEnvironment.getMasterScheduler()); final long startTime = s.getCurrentTime(); s.runOneTask(); assertThat(events).named("firstEvent").containsExactly("handler1"); assertThat(s.getCurrentTime()).named("firstEvent:time").isEqualTo(100 + startTime); s.runOneTask(); assertThat(events).named("secondEvent").containsExactly("handler1", "handler2"); assertThat(s.getCurrentTime()).named("secondEvent:time").isEqualTo(200 + startTime);
@Test public void removedMessage_isNotSentToHandler() { enqueueMessage(testMessage, 200); assertThat(scheduler.size()).named("scheduler size:before").isEqualTo(1); removeMessages(handler, testMessage.what, null); scheduler.advanceToLastPostedRunnable(); assertThat(scheduler.size()).named("scheduler size:after").isEqualTo(0); assertThat(handler.handled).named("handled").isEmpty(); }
@Test public void nestedPostDelayed_whileUnpaused_doesntAutomaticallyExecute3() { final List<Integer> order = new ArrayList<>(); scheduler.unPause(); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(1); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(3); } }, 1); order.add(2); } }, 0); assertThat(order).named("order:before").containsExactly(1, 2); assertThat(scheduler.size()).named("size:before").isEqualTo(1); scheduler.advanceToLastPostedRunnable(); assertThat(order).named("order:after").containsExactly(1, 2, 3); assertThat(scheduler.size()).named("size:after").isEqualTo(0); assertThat(scheduler.getCurrentTime()).named("time:after").isEqualTo(1 + startTime); }
@Test public void nestedPostDelayed_whenIdlingConstantly_automaticallyExecutes3After() { final List<Integer> order = new ArrayList<>(); scheduler.setIdleState(CONSTANT_IDLE); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(1); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(3); } }, 1); order.add(2); } }, 0); assertThat(order).named("order").containsExactly(1, 2, 3); assertThat(scheduler.size()).named("size").isEqualTo(0); assertThat(scheduler.getCurrentTime()).named("time").isEqualTo(1 + startTime); }
@Test public void nestedPostAtFront_whilePaused_runsBeforeSubsequentPost() { final List<Integer> order = new ArrayList<>(); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(1); scheduler.postAtFrontOfQueue(new Runnable() { @Override public void run() { order.add(3); } }); order.add(2); } }, 0); scheduler.postDelayed(new Runnable() { @Override public void run() { order.add(4); } }, 0); scheduler.advanceToLastPostedRunnable(); assertThat(order).named("order").containsExactly(1, 2, 3, 4); assertThat(scheduler.size()).named("size").isEqualTo(0); }
@Test public void boolArrayFromPlainIterable() { // Test to ensure that PrimitiveArrayFactory understands how to create an appropriate backing // arrays from various sizes of plain Iterable input. This test also covers the code paths // used by int64Array() and float64Array(). for (int i = 0; i < 50; ++i) { Boolean[] data = new Boolean[i]; for (int j = 0; j < data.length; ++j) { data[j] = (j % 3 == 2) ? null : ((j % 3) == 1); } String name = "boolArray() of length " + i; Value v = Value.boolArray(plainIterable(data)); assertThat(v.isNull()).named(name).isFalse(); assertThat(v.getBoolArray()).named(name).containsExactly((Object[]) data).inOrder(); } }