Added a unit test against the sample operator

Author: jmhofer

rxjava-core/src/main/java/rx/operators/OperationSample.java

@@ -15,23 +15,24 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.Tester.UnitTest.*;
 
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
 import rx.concurrency.Schedulers;
+import rx.concurrency.TestScheduler;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Func1;
@@ -78,7 +79,7 @@ public Subscription call(final Observer<T> observer) {
                 public void onCompleted() { /* the clock never completes */ }
 
                 @Override
-                public void onError(Exception e) { /* the clock has no errors */ }
+                public void onError(@SuppressWarnings("unused") Exception e) { /* the clock has no errors */ }
 
                 @Override
                 public void onNext(@SuppressWarnings("unused") Long tick) {
@@ -119,6 +120,77 @@ public void call() {
     }
 
     public static class UnitTest {
-        // TODO
+        private TestScheduler scheduler;
+        private Observer<Long> observer;
+        
+        @Before
+        @SuppressWarnings("unchecked") // due to mocking
+        public void before() {
+            scheduler = new TestScheduler();
+            observer = mock(Observer.class);
+        }
+        
+        @Test
+        public void testSample() {
+            Observable<Long> source = Observable.create(new Func1<Observer<Long>, Subscription>() {
+                @Override
+                public Subscription call(final Observer<Long> observer1) {
+                    scheduler.schedule(new Action0() {
+                        @Override
+                        public void call() {
+                            observer1.onNext(1L);
+                        }
+                    }, 1, TimeUnit.SECONDS);
+                    scheduler.schedule(new Action0() {
+                        @Override
+                        public void call() {
+                            observer1.onNext(2L);
+                        }
+                    }, 2, TimeUnit.SECONDS);
+                    scheduler.schedule(new Action0() {
+                        @Override
+                        public void call() {
+                            observer1.onCompleted();
+                        }
+                    }, 3, TimeUnit.SECONDS);
+                    
+                    return Subscriptions.empty();
+                }
+            });
+            
+            Observable<Long> sampled = Observable.create(OperationSample.sample(source, 400L, TimeUnit.MILLISECONDS, scheduler));
+            sampled.subscribe(observer);
+            
+            InOrder inOrder = inOrder(observer);
+
+            scheduler.advanceTimeTo(800L, TimeUnit.MILLISECONDS);
+            verify(observer, never()).onNext(any(Long.class));
+            verify(observer, never()).onCompleted();
+            verify(observer, never()).onError(any(Exception.class));
+            
+            scheduler.advanceTimeTo(1200L, TimeUnit.MILLISECONDS);
+            inOrder.verify(observer, times(1)).onNext(1L);
+            verify(observer, never()).onNext(2L);
+            verify(observer, never()).onCompleted();
+            verify(observer, never()).onError(any(Exception.class));
+
+            scheduler.advanceTimeTo(1600L, TimeUnit.MILLISECONDS);
+            inOrder.verify(observer, times(1)).onNext(1L);
+            verify(observer, never()).onNext(2L);
+            verify(observer, never()).onCompleted();
+            verify(observer, never()).onError(any(Exception.class));
+            
+            scheduler.advanceTimeTo(2000L, TimeUnit.MILLISECONDS);
+            inOrder.verify(observer, never()).onNext(1L);
+            inOrder.verify(observer, times(1)).onNext(2L);
+            verify(observer, never()).onCompleted();
+            verify(observer, never()).onError(any(Exception.class));
+            
+            scheduler.advanceTimeTo(3000L, TimeUnit.MILLISECONDS);
+            inOrder.verify(observer, never()).onNext(1L);
+            inOrder.verify(observer, times(2)).onNext(2L);
+            verify(observer, times(1)).onCompleted();
+            verify(observer, never()).onError(any(Exception.class));
+        }
     }
 }