From 4378e8acba1b0078cce6fc2519b0d37812d89eff Mon Sep 17 00:00:00 2001
From: Artem Zinnatullin <artem.zinnatullin@gmail.com>
Date: Wed, 23 Mar 2016 03:25:22 +0300
Subject: [PATCH] 1.x: Prevent Single.zip() of zero Singles

---
 src/main/java/rx/Single.java                  |  3 ++-
 .../internal/operators/SingleOperatorZip.java |  6 ++++++
 src/test/java/rx/SingleTest.java              | 20 +++++++++++++++++++
 3 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 3489f1a55c..dcd296483d 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -1235,7 +1235,8 @@ public R call(Object... args) {
      * </dl>
      *
      * @param singles
-     *            an Iterable of source Singles
+     *            an Iterable of source Singles. Should not be empty because {@link Single} either emits result or error.
+     *            {@link java.util.NoSuchElementException} will be emit as error if Iterable will be empty.
      * @param zipFunction
      *            a function that, when applied to an item emitted by each of the source Singles, results in
      *            an item that will be emitted by the resulting Single
diff --git a/src/main/java/rx/internal/operators/SingleOperatorZip.java b/src/main/java/rx/internal/operators/SingleOperatorZip.java
index 936750941f..d80c5ae056 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorZip.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorZip.java
@@ -7,6 +7,7 @@
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.CompositeSubscription;
 
+import java.util.NoSuchElementException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -16,6 +17,11 @@ public static <T, R> Single<R> zip(final Single<? extends T>[] singles, final Fu
         return Single.create(new Single.OnSubscribe<R>() {
             @Override
             public void call(final SingleSubscriber<? super R> subscriber) {
+                if (singles.length == 0) {
+                    subscriber.onError(new NoSuchElementException("Can't zip 0 Singles."));
+                    return;
+                }
+
                 final AtomicInteger wip = new AtomicInteger(singles.length);
                 final AtomicBoolean once = new AtomicBoolean();
                 final Object[] values = new Object[singles.length];
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 8c6257784d..24855bf415 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -340,6 +340,26 @@ public String call(Object... args) {
         ts.assertCompleted();
     }
 
+    @Test
+    public void zipEmptyIterableShouldThrow() {
+        TestSubscriber<Object> testSubscriber = new TestSubscriber<Object>();
+        Iterable<Single<Object>> singles = Collections.emptyList();
+
+        Single
+                .zip(singles, new FuncN<Object>() {
+                    @Override
+                    public Object call(Object... args) {
+                        throw new IllegalStateException("Should not be called");
+                    }
+                })
+                .subscribe(testSubscriber);
+
+        testSubscriber.assertNoValues();
+        testSubscriber.assertNotCompleted();
+        testSubscriber.assertError(NoSuchElementException.class);
+        assertEquals("Can't zip 0 Singles.", testSubscriber.getOnErrorEvents().get(0).getMessage());
+    }
+
     @Test
     public void testZipWith() {
         TestSubscriber<String> ts = new TestSubscriber<String>();