Extract the Swing unit tests so that test classes don't have to be on the main compile classpath.

Author: ldaley

rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java

@@ -15,31 +15,20 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-import java.awt.EventQueue;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import javax.swing.SwingUtilities;
-import javax.swing.Timer;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.InOrder;
-
 import rx.Scheduler;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
 import rx.util.functions.Func2;
 
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
 /**
  * Executes work on the Swing UI thread.
  * This scheduler should only be used with actions that execute quickly.
@@ -157,118 +146,4 @@ private static void assertThatTheDelayIsValidForTheSwingTimer(long delay) {
         }
     }
 
-    public static class UnitTest {
-        @Rule
-        public ExpectedException exception = ExpectedException.none();
-
-        @Test
-        public void testInvalidDelayValues() {
-            final SwingScheduler scheduler = new SwingScheduler();
-            final Action0 action = mock(Action0.class);
-
-            exception.expect(IllegalArgumentException.class);
-            scheduler.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS);
-
-            exception.expect(IllegalArgumentException.class);
-            scheduler.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS);
-
-            exception.expect(IllegalArgumentException.class);
-            scheduler.schedulePeriodically(action, 1L + Integer.MAX_VALUE, 100L, TimeUnit.MILLISECONDS);
-
-            exception.expect(IllegalArgumentException.class);
-            scheduler.schedulePeriodically(action, 100L, 1L + Integer.MAX_VALUE / 1000, TimeUnit.SECONDS);
-        }
-
-        @Test
-        public void testPeriodicScheduling() throws Exception {
-            final SwingScheduler scheduler = new SwingScheduler();
-
-            final CountDownLatch latch = new CountDownLatch(4);
-
-            final Action0 innerAction = mock(Action0.class);
-            final Action0 action = new Action0() {
-                @Override
-                public void call() {
-                    try {
-                        innerAction.call();
-                        assertTrue(SwingUtilities.isEventDispatchThread());
-                    } finally {
-                        latch.countDown();
-                    }
-                }
-            };
-
-            Subscription sub = scheduler.schedulePeriodically(action, 50, 200, TimeUnit.MILLISECONDS);
-
-            if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
-                fail("timed out waiting for tasks to execute");
-            }
-
-            sub.unsubscribe();
-            waitForEmptyEventQueue();
-            verify(innerAction, times(4)).call();
-        }
-
-        @Test
-        public void testNestedActions() throws Exception {
-            final SwingScheduler scheduler = new SwingScheduler();
-
-            final Action0 firstStepStart = mock(Action0.class);
-            final Action0 firstStepEnd = mock(Action0.class);
-
-            final Action0 secondStepStart = mock(Action0.class);
-            final Action0 secondStepEnd = mock(Action0.class);
-
-            final Action0 thirdStepStart = mock(Action0.class);
-            final Action0 thirdStepEnd = mock(Action0.class);
-
-            final Action0 firstAction = new Action0() {
-                @Override
-                public void call() {
-                    assertTrue(SwingUtilities.isEventDispatchThread());
-                    firstStepStart.call();
-                    firstStepEnd.call();
-                }
-            };
-            final Action0 secondAction = new Action0() {
-                @Override
-                public void call() {
-                    assertTrue(SwingUtilities.isEventDispatchThread());
-                    secondStepStart.call();
-                    scheduler.schedule(firstAction);
-                    secondStepEnd.call();
-                }
-            };
-            final Action0 thirdAction = new Action0() {
-                @Override
-                public void call() {
-                    assertTrue(SwingUtilities.isEventDispatchThread());
-                    thirdStepStart.call();
-                    scheduler.schedule(secondAction);
-                    thirdStepEnd.call();
-                }
-            };
-
-            InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
-
-            scheduler.schedule(thirdAction);
-            waitForEmptyEventQueue();
-
-            inOrder.verify(thirdStepStart, times(1)).call();
-            inOrder.verify(thirdStepEnd, times(1)).call();
-            inOrder.verify(secondStepStart, times(1)).call();
-            inOrder.verify(secondStepEnd, times(1)).call();
-            inOrder.verify(firstStepStart, times(1)).call();
-            inOrder.verify(firstStepEnd, times(1)).call();
-        }
-
-        private static void waitForEmptyEventQueue() throws Exception {
-            EventQueue.invokeAndWait(new Runnable() {
-                @Override
-                public void run() {
-                    // nothing to do, we're just waiting here for the event queue to be emptied
-                }
-            });
-        }
-    }
 }

rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/AbstractButtonSource.java

@@ -15,23 +15,16 @@
  */
 package rx.swing.sources;
 
-import static org.mockito.Mockito.*;
-
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-
-import javax.swing.AbstractButton;
-
-import org.junit.Test;
-import org.mockito.Matchers;
-
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
-import rx.util.functions.Action1;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 
 public enum AbstractButtonSource { ; // no instances
 
@@ -60,42 +53,4 @@ public void call() {
         });
     }
 
-    public static class UnitTest {
-        @Test
-        public void testObservingActionEvents() {
-            @SuppressWarnings("unchecked")
-            Action1<ActionEvent> action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1<Throwable> error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            final ActionEvent event = new ActionEvent(this, 1, "command");
-            
-            @SuppressWarnings("serial")
-            class TestButton extends AbstractButton {
-                void testAction() {
-                    fireActionPerformed(event);
-                }
-            }
-            
-            TestButton button = new TestButton();
-            Subscription sub = fromActionOf(button).subscribe(action, error, complete);
-            
-            verify(action, never()).call(Matchers.<ActionEvent>any());
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-            
-            button.testAction();
-            verify(action, times(1)).call(Matchers.<ActionEvent>any());
-            
-            button.testAction();
-            verify(action, times(2)).call(Matchers.<ActionEvent>any());
-            
-            sub.unsubscribe();
-            button.testAction();
-            verify(action, times(2)).call(Matchers.<ActionEvent>any());
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-        }
-    }
 }

rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java

@@ -15,32 +15,22 @@
  */
 package rx.swing.sources;
 
-import static java.util.Arrays.*;
-import static org.mockito.Mockito.*;
-
-import java.awt.Component;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
-import javax.swing.JPanel;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Matchers;
-
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
-import rx.util.functions.Action1;
 import rx.util.functions.Func1;
 import rx.util.functions.Func2;
 
+import java.awt.*;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 public enum KeyEventSource { ; // no instances
 
     /**
@@ -110,88 +100,5 @@ public Boolean call(KeyEvent event) {
 
         return filteredKeyEvents.scan(Collections.<Integer>emptySet(), new CollectKeys());
     }
-    
-    public static class UnitTest {
-        private Component comp = new JPanel();
-        
-        @Test
-        public void testObservingKeyEvents() {
-            @SuppressWarnings("unchecked")
-            Action1<KeyEvent> action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1<Throwable> error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            final KeyEvent event = mock(KeyEvent.class);
-            
-            Subscription sub = fromKeyEventsOf(comp).subscribe(action, error, complete);
-            
-            verify(action, never()).call(Matchers.<KeyEvent>any());
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-            
-            fireKeyEvent(event);
-            verify(action, times(1)).call(Matchers.<KeyEvent>any());
-            
-            fireKeyEvent(event);
-            verify(action, times(2)).call(Matchers.<KeyEvent>any());
-            
-            sub.unsubscribe();
-            fireKeyEvent(event);
-            verify(action, times(2)).call(Matchers.<KeyEvent>any());
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-        }
-        
-        @Test
-        public void testObservingPressedKeys() {
-            @SuppressWarnings("unchecked")
-            Action1<Set<Integer>> action = mock(Action1.class);
-            @SuppressWarnings("unchecked")
-            Action1<Throwable> error = mock(Action1.class);
-            Action0 complete = mock(Action0.class);
-            
-            Subscription sub = currentlyPressedKeysOf(comp).subscribe(action, error, complete);
-            
-            InOrder inOrder = inOrder(action);
-            inOrder.verify(action, times(1)).call(Collections.<Integer>emptySet());
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-            
-            fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
-            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1)));
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-
-            fireKeyEvent(keyEvent(2, KeyEvent.KEY_PRESSED));
-            fireKeyEvent(keyEvent(KeyEvent.VK_UNDEFINED, KeyEvent.KEY_TYPED));
-            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1, 2)));
-
-            fireKeyEvent(keyEvent(2, KeyEvent.KEY_RELEASED));
-            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1)));
-
-            fireKeyEvent(keyEvent(3, KeyEvent.KEY_RELEASED));
-            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1)));
-
-            fireKeyEvent(keyEvent(1, KeyEvent.KEY_RELEASED));
-            inOrder.verify(action, times(1)).call(Collections.<Integer>emptySet());
-
-            sub.unsubscribe();
 
-            fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
-            inOrder.verify(action, never()).call(Matchers.<Set<Integer>>any());
-            verify(error, never()).call(Matchers.<Throwable>any());
-            verify(complete, never()).call();
-        }
-
-        private KeyEvent keyEvent(int keyCode, int id) {
-            return new KeyEvent(comp, id, -1L, 0, keyCode, ' ');
-        }
-        
-        private void fireKeyEvent(KeyEvent event) {
-            for (KeyListener listener: comp.getKeyListeners()) {
-                listener.keyTyped(event);
-            }
-        }
-    }
 }