@Test
public void testUnsubscribeAfterTake() {
Subscription s = mock(Subscription.class);
TestObservable w = new TestObservable(s, "one", "two", "three");
@SuppressWarnings("unchecked")
Observer<String> aObserver = mock(Observer.class);
Observable<String> take = Observable.create(take(w, 1));
take.subscribe(aObserver);
// wait for the Observable to complete
try {
w.t.join();
} catch (Throwable e) {
e.printStackTrace();
fail(e.getMessage());
}
System.out.println("TestObservable thread finished");
verify(aObserver, times(1)).onNext("one");
verify(aObserver, never()).onNext("two");
verify(aObserver, never()).onNext("three");
verify(aObserver, times(1)).onCompleted();
verify(s, times(1)).unsubscribe();
verifyNoMoreInteractions(aObserver);
}
/** When BACKUP_PACKET is received, updates are written to store */
@Test
public void whenBACKUP_PACKETThenWriteUpdates() throws Exception {
final ByteBuffer buffer1 = randomBuffer(50);
final ByteBuffer buffer2 = randomBuffer(50);
final ByteBuffer buffer3 = randomBuffer(50);
final BACKUP_PACKET bp =
Message.BACKUP_PACKET(
7,
Arrays.asList(
Message.BACKUP(id(1), 4, buffer1),
Message.BACKUP(id(2), 5, buffer2),
Message.BACKUP(id(3), 6, buffer3)));
bp.setNode(sh(10));
mm.receive(bp);
InOrder inOrder = inOrder(store, comm);
inOrder.verify(store).beginTransaction();
inOrder
.verify(store)
.write(eq(id(1)), eq(sh(10)), eq(4L), eq(Persistables.toByteArray(buffer1)), anyObject());
inOrder
.verify(store)
.write(eq(id(2)), eq(sh(10)), eq(5L), eq(Persistables.toByteArray(buffer2)), anyObject());
inOrder
.verify(store)
.write(eq(id(3)), eq(sh(10)), eq(6L), eq(Persistables.toByteArray(buffer3)), anyObject());
inOrder.verify(store).commit(anyObject());
inOrder.verify(comm).send(argThat(equalTo(Message.BACKUP_PACKETACK(bp))));
verify(monitor).addTransaction(3);
verifyNoMoreInteractions(monitor);
}
@Test
public void testTakeZeroDoesntLeakError() {
final AtomicBoolean subscribed = new AtomicBoolean(false);
final AtomicBoolean unSubscribed = new AtomicBoolean(false);
Observable<String> source =
Observable.create(
new Func1<Observer<String>, Subscription>() {
@Override
public Subscription call(Observer<String> observer) {
subscribed.set(true);
observer.onError(new Throwable("test failed"));
return new Subscription() {
@Override
public void unsubscribe() {
unSubscribed.set(true);
}
};
}
});
@SuppressWarnings("unchecked")
Observer<String> aObserver = mock(Observer.class);
Observable.create(take(source, 0)).subscribe(aObserver);
assertTrue("source subscribed", subscribed.get());
assertTrue("source unsubscribed", unSubscribed.get());
verify(aObserver, never()).onNext(anyString());
// even though onError is called we take(0) so shouldn't see it
verify(aObserver, never()).onError(any(Throwable.class));
verify(aObserver, times(1)).onCompleted();
verifyNoMoreInteractions(aObserver);
}
@Test
public void shouldResetMultipleMocks() {
mock.simpleMethod();
mockTwo.simpleMethod();
reset(mock, mockTwo);
verifyNoMoreInteractions(mock, mockTwo);
}
@Test
public void shouldNotLogVoidReturnValue() {
returnVoidClass.foo();
verify(log, atLeast(0)).isDebugEnabled();
verify(log).debug("foo", NO_ARGS);
verifyNoMoreInteractions(log);
}
@Test
public void whenWithAspectMultipleTimesThenShouldNotResetAndShouldRegisterEveryAspect() {
context.withAspect(AnAspect.class);
context.withAspect(OtherAspect.class);
verify(weaverMock, times(2)).registerAspect((Class<?>) anyObject());
verifyNoMoreInteractions(weaverMock);
}
/** When INV is received but previous owner is wrong, don't change the owner and reply INV. */
@Test
public void whenINVAndWrongPreviousOwnerThenINV() throws Exception {
when(store.casOwner(id(154), sh(5), sh(10))).thenReturn(sh(20));
final Message.INV inv = Message.INV(sh(10), id(154), sh(5));
mm.receive(inv);
verify(store).casOwner(id(154), sh(5), sh(10));
verify(comm).send(argThat(equalTo(Message.INV(inv, id(154), sh(20)))));
verify(monitor).addOwnerServed();
verifyNoMoreInteractions(monitor);
}
/**
* When INV is received, the owner is registered in the store as the owner of the line, and reply
* INVACK.
*/
@Test
public void whenINVThenMarkOwnerAndINVACK() throws Exception {
when(store.casOwner(id(154), sh(5), sh(10))).thenReturn(sh(10));
final Message.INV inv = Message.INV(sh(10), id(154), sh(5));
mm.receive(inv);
verify(store).casOwner(id(154), sh(5), sh(10));
verify(comm).send(argThat(equalTo(Message.INVACK(inv))));
verify(monitor).addOwnerWrite();
verifyNoMoreInteractions(monitor);
}
/** When GET is received and owner is a node other than server, reply with a CHNGD_OWNR */
@Test
public void whenGETAndHasOwnerThenReplyCHNGD_OWNR() throws Exception {
when(store.casOwner(id(154), sh(0), sh(10))).thenReturn(sh(3));
final LineMessage get = Message.GET(sh(10), id(154));
mm.receive(get);
verify(comm).send(argThat(equalTo(Message.CHNGD_OWNR(get, id(154), sh(3), true))));
verify(monitor).addOwnerServed();
verifyNoMoreInteractions(monitor);
}
/**
* When GET is received and owner is not found but line is reserved, then create line and reply
* with PUTX
*/
@Test
public void whenGETReservedAndNoOwnerThenCreateAndReplyPUTX() throws Exception {
when(store.casOwner(15, sh(-1), sh(10))).thenReturn(sh(10));
final LineMessage get = Message.GET(sh(10), 15);
mm.receive(get);
verify(store).casOwner(15, sh(-1), sh(10));
verify(store).write(15, sh(10), 1, new byte[0], null);
verify(comm).send(argThat(equalTo(Message.PUTX(get, 15, new short[0], 0, 1, null))));
verify(monitor).addObjectServed();
verify(monitor).addOwnerWrite();
verifyNoMoreInteractions(monitor);
}
@Test
public void shouldVerifyObjectVarargs() {
mock.withObjectVarargs(1);
mock.withObjectVarargs(2, "1", new ArrayList<Object>(), new Integer(1));
mock.withObjectVarargs(3, new Integer(1));
verify(mock).withObjectVarargs(1);
verify(mock).withObjectVarargs(2, "1", new ArrayList<Object>(), new Integer(1));
try {
verifyNoMoreInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
}
}
/** When GET is received and server is owner then reply with PUTX */
@Test
public void whenGETAndServerIsOwnerThenReplyPUTX() throws Exception {
when(store.casOwner(id(154), sh(0), sh(10))).thenReturn(sh(10));
when(store.read(id(154))).thenReturn(new MainMemoryEntry(1234, new byte[] {3, 4, 5}));
final LineMessage get = Message.GET(sh(10), id(154));
mm.receive(get);
verify(store).casOwner(id(154), sh(0), sh(10));
verify(store).read(id(154));
verify(comm)
.send(
argThat(
equalTo(
Message.PUTX(
get,
id(154),
new short[0],
0,
1234,
ByteBuffer.wrap(new byte[] {3, 4, 5})))));
verify(monitor).addObjectServed();
verify(monitor).addOwnerWrite();
verifyNoMoreInteractions(monitor);
}
@Test
public void testTakeDoesntLeakErrors() {
Observable<String> source =
Observable.create(
new Func1<Observer<String>, Subscription>() {
@Override
public Subscription call(Observer<String> observer) {
observer.onNext("one");
observer.onError(new Throwable("test failed"));
return Subscriptions.empty();
}
});
@SuppressWarnings("unchecked")
Observer<String> aObserver = mock(Observer.class);
Observable.create(take(source, 1)).subscribe(aObserver);
verify(aObserver, times(1)).onNext("one");
// even though onError is called we take(1) so shouldn't see it
verify(aObserver, never()).onError(any(Throwable.class));
verify(aObserver, times(1)).onCompleted();
verifyNoMoreInteractions(aObserver);
}