@Test
public void onlyFirstShouldSubscribeAndLastUnsubscribe() {
final AtomicInteger subscriptionCount = new AtomicInteger();
final AtomicInteger unsubscriptionCount = new AtomicInteger();
Observable<Integer> observable =
Observable.create(
new Observable.OnSubscribeFunc<Integer>() {
@Override
public Subscription onSubscribe(Observer<? super Integer> observer) {
subscriptionCount.incrementAndGet();
return Subscriptions.create(
new Action0() {
@Override
public void call() {
unsubscriptionCount.incrementAndGet();
}
});
}
});
Observable<Integer> refCounted = observable.publish().refCount();
@SuppressWarnings("unchecked")
Observer<Integer> observer = mock(Observer.class);
Subscription first = refCounted.subscribe(observer);
assertEquals(1, subscriptionCount.get());
Subscription second = refCounted.subscribe(observer);
assertEquals(1, subscriptionCount.get());
first.unsubscribe();
assertEquals(0, unsubscriptionCount.get());
second.unsubscribe();
assertEquals(1, unsubscriptionCount.get());
}
@Test
public void countDownTest() {
EventSource<Void> src1 = new EventSource<Void>();
EventSource<Void> src2 = new EventSource<Void>();
EventSource<Void> reset = new EventSource<Void>();
BiFunction<Integer, Void, Tuple2<Integer, Optional<String>>> countdown =
(s, i) -> s == 1 ? t(3, Optional.of("COUNTDOWN REACHED")) : t(s - 1, Optional.empty());
EventStream<String> countdowns =
StateMachine.init(3)
.on(src1)
.transmit(countdown)
.on(src2)
.transmit(countdown)
.on(reset)
.transition((s, i) -> 3)
.toEventStream();
Counter counter = new Counter();
Subscription sub = countdowns.hook(x -> counter.inc()).pin();
src1.push(null);
src2.push(null);
assertEquals(0, counter.get());
src1.push(null);
assertEquals(1, counter.getAndReset());
src2.push(null);
src2.push(null);
reset.push(null);
assertEquals(0, counter.get());
src2.push(null);
assertEquals(0, counter.get());
src1.push(null);
assertEquals(0, counter.get());
src2.push(null);
assertEquals(1, counter.getAndReset());
sub.unsubscribe();
src1.push(null);
src1.push(null);
src1.push(null);
src1.push(null);
src1.push(null);
src1.push(null);
assertEquals(0, counter.get());
}
@SuppressWarnings("unchecked")
// mocking is unchecked, unfortunately
@Test
public void testPeriodicScheduling() {
final Func1<Long, Void> calledOp = mock(Func1.class);
final TestScheduler scheduler = new TestScheduler();
Subscription subscription =
scheduler.schedulePeriodically(
new Action0() {
@Override
public void call() {
System.out.println(scheduler.now());
calledOp.call(scheduler.now());
}
},
1,
2,
TimeUnit.SECONDS);
verify(calledOp, never()).call(anyLong());
InOrder inOrder = Mockito.inOrder(calledOp);
scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
inOrder.verify(calledOp, never()).call(anyLong());
scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
inOrder.verify(calledOp, times(1)).call(1000L);
scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
inOrder.verify(calledOp, never()).call(3000L);
scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
inOrder.verify(calledOp, times(1)).call(3000L);
scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
inOrder.verify(calledOp, times(1)).call(5000L);
inOrder.verify(calledOp, times(1)).call(7000L);
subscription.unsubscribe();
scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
inOrder.verify(calledOp, never()).call(anyLong());
}
@Test
public void testRefCount() {
TestScheduler s = new TestScheduler();
Observable<Long> interval =
Observable.interval(100, TimeUnit.MILLISECONDS, s).publish().refCount();
// subscribe list1
final List<Long> list1 = new ArrayList<Long>();
Subscription s1 =
interval.subscribe(
new Action1<Long>() {
@Override
public void call(Long t1) {
list1.add(t1);
}
});
s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
assertEquals(2, list1.size());
assertEquals(0L, list1.get(0).longValue());
assertEquals(1L, list1.get(1).longValue());
// subscribe list2
final List<Long> list2 = new ArrayList<Long>();
Subscription s2 =
interval.subscribe(
new Action1<Long>() {
@Override
public void call(Long t1) {
list2.add(t1);
}
});
s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
// list 1 should have 5 items
assertEquals(5, list1.size());
assertEquals(2L, list1.get(2).longValue());
assertEquals(3L, list1.get(3).longValue());
assertEquals(4L, list1.get(4).longValue());
// list 2 should only have 3 items
assertEquals(3, list2.size());
assertEquals(2L, list2.get(0).longValue());
assertEquals(3L, list2.get(1).longValue());
assertEquals(4L, list2.get(2).longValue());
// unsubscribe list1
s1.unsubscribe();
// advance further
s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
// list 1 should still have 5 items
assertEquals(5, list1.size());
// list 2 should have 6 items
assertEquals(6, list2.size());
assertEquals(5L, list2.get(3).longValue());
assertEquals(6L, list2.get(4).longValue());
assertEquals(7L, list2.get(5).longValue());
// unsubscribe list2
s2.unsubscribe();
// advance further
s.advanceTimeBy(1000, TimeUnit.MILLISECONDS);
// subscribing a new one should start over because the source should have been unsubscribed
// subscribe list3
final List<Long> list3 = new ArrayList<Long>();
Subscription s3 =
interval.subscribe(
new Action1<Long>() {
@Override
public void call(Long t1) {
list3.add(t1);
}
});
s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
assertEquals(2, list3.size());
assertEquals(0L, list3.get(0).longValue());
assertEquals(1L, list3.get(1).longValue());
}
