I understand why there are separate disconnected buffers, I still don't understand why there are `onNext` events with empty lists. There are 5 events when I expect 2.

Here is the code:

```java
@Test
        public void testObservableBasedOpenerAndCloser() {
            Observable<String> source = Observable.create(new Func1<Observer<String>, Subscription>() {
                @Override
                public Subscription call(Observer<String> observer) {
                    push(observer, "one", 10);
                    push(observer, "two", 60);
                    push(observer, "three", 110);
                    push(observer, "four", 160);
                    push(observer, "five", 210);
                    complete(observer, 500);
                    return Subscriptions.empty();
                }
            });

            Observable<BufferOpening> openings = Observable.create(new Func1<Observer<BufferOpening>, Subscription>() {
                @Override
                public Subscription call(Observer<BufferOpening> observer) {
                    push(observer, BufferOpenings.create(), 50);
                    push(observer, BufferOpenings.create(), 200);
                    complete(observer, 250);
                    return Subscriptions.empty();
                }
            });

            Func1<BufferOpening, Observable<BufferClosing>> closer = new Func1<BufferOpening, Observable<BufferClosing>>() {
                @Override
                public Observable<BufferClosing> call(BufferOpening opening) {
                    return Observable.create(new Func1<Observer<BufferClosing>, Subscription>() {
                        @Override
                        public Subscription call(Observer<BufferClosing> observer) {
                            push(observer, BufferClosings.create(), 100);
                            complete(observer, 101);
                            return Subscriptions.empty();
                        }
                    });
                }
            };

            Observable<List<String>> buffered = Observable.create(buffer(source, openings, closer));
            buffered.subscribe(observer);

            InOrder inOrder = Mockito.inOrder(observer);
            scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
            inOrder.verify(observer, Mockito.times(1)).onNext(list("two", "three"));
            inOrder.verify(observer, Mockito.times(1)).onNext(list("five"));
            inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Exception.class));
            inOrder.verify(observer, Mockito.times(1)).onCompleted();
        }
```

I see 2 `BufferOpenings` created thus expect to only receive 2 `onNext` calls, but in fact receive 5, 3 of them are empty buffers.

I think empty buffers are being created and then flushed when `onComplete` happens.