Fix the bug that int overflow can bypass the range check

Author: zsxwing

rxjava-core/src/main/java/rx/Observable.java

@@ -2301,15 +2301,18 @@ public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservab
      *            the number of sequential Integers to generate
      * @return an Observable that emits a range of sequential Integers
      * @throws IllegalArgumentException
-     *             if {@code count} is less than zero
+     *             if {@code count} is less than zero, or if {@code start} + {@code count} - 1 exceeds {@code Integer.MAX_VALUE}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-range">RxJava Wiki: range()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229460.aspx">MSDN: Observable.Range</a>
      */
     public final static Observable<Integer> range(int start, int count) {
         if (count < 0) {
             throw new IllegalArgumentException("Count can not be negative");
         }
-        if ((start + count) > Integer.MAX_VALUE) {
+        if (count == 0) {
+            return Observable.empty();
+        }
+        if (start > Integer.MAX_VALUE - count + 1) {
             throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
         }
         return Observable.create(new OnSubscribeRange(start, start + (count - 1)));

rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java

@@ -16,6 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -67,4 +68,29 @@ public void call(Integer t1) {
         verify(observer, times(1)).onCompleted();
         assertEquals(3, count.get());
     }
+
+    @Test
+    public void testRangeWithOverflow() {
+        Observable.range(1, 0);
+    }
+
+    @Test
+    public void testRangeWithOverflow2() {
+        Observable.range(Integer.MAX_VALUE, 0);
+    }
+
+    @Test
+    public void testRangeWithOverflow3() {
+        Observable.range(1, Integer.MAX_VALUE);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testRangeWithOverflow4() {
+        Observable.range(2, Integer.MAX_VALUE);
+    }
+
+    @Test
+    public void testRangeWithOverflow5() {
+        assertFalse(Observable.range(Integer.MIN_VALUE, 0).toBlocking().getIterator().hasNext());
+    }
 }