Sorry for my ambiguous comment.

Here is the test: 
```java
    @SuppressWarnings("unchecked")
    @Test
    public void testOnErrorWithInternalObserver() {

        Observable<String> w = Observable.zip(
                Observable.<Integer> error(new RuntimeException()),
                Observable.<Integer> error(new RuntimeException()),
                new Func2<Integer,Integer,String>(){

                    @Override
                    public String call(Integer t1, Integer t2) {
                        return t1 + "" + t2;
                    }
                });
        
        final Observer<String> observer = mock(Observer.class);
        w.subscribe(new Observer<String>() {

            @Override
            public void onCompleted() {
                observer.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onNext(String t) {
                observer.onNext(t);
            }
            
        });

        verify(observer, times(1)).onError(isA(RuntimeException.class)); // The current implementation will emit 2 errors.
        verify(observer, never()).onCompleted();
        verify(observer, never()).onNext(any(String.class));
    }
```