ReactiveX · ldaley · Oct 29, 2014 · Oct 8, 2014
diff --git a/src/main/java/rx/internal/SubjectProcessor.java b/src/main/java/rx/internal/SubjectProcessor.java
@@ -0,0 +1,61 @@
+package rx.internal;
+
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import rx.observers.Subscribers;
+import rx.subjects.Subject;
+
+/**
+ * The {@link SubjectProcessor} wraps a {@link Subject}.
+ */
+public class SubjectProcessor<T, R> implements Processor<T, R> {
+
+    /**
+     * The wrapped Rx {@link Subject} as a {@link Subscriber}.
+     */
+    private final Subscriber<T> subscriber;
+
+    /**
+     * The wrapped Rx {@link Subject} as a {@link Publisher}.
+     */
+    private final Publisher<R> publisher;
+
+    /**
+     * Creates a new {@link SubjectProcessor}.
+     *
+     * @param subject the wrapped {@link Subject}.
+     */
+    public SubjectProcessor(final Subject<T, R> subject) {
+        this.subscriber = new PublisherSubscriber<T>(Subscribers.from(subject));
+        this.publisher = new ObservablePublisher<R>(subject);
+    }
+
+    @Override
+    public void onSubscribe(Subscription s) {
+        subscriber.onSubscribe(s);
+    }
+
+    @Override
+    public void onNext(T t) {
+        subscriber.onNext(t);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        subscriber.onError(t);
+    }
+
+    @Override
+    public void onComplete() {
+        subscriber.onComplete();
+    }
+
+    @Override
+    public void subscribe(Subscriber<? super R> s) {
+        publisher.subscribe(s);
+    }
+
+}
diff --git a/src/test/java/rx/RxIdentityProcessorTest.java b/src/test/java/rx/RxIdentityProcessorTest.java
@@ -0,0 +1,43 @@
+package rx;
+
+import org.reactivestreams.Processor;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.tck.IdentityProcessorVerification;
+import org.reactivestreams.tck.TestEnvironment;
+import org.testng.annotations.Test;
+
+import rx.internal.SubjectProcessor;
+import rx.subjects.PublishSubject;
+import rx.test.IterableDecrementer;
+
+@Test
+public class RxIdentityProcessorTest extends IdentityProcessorVerification<Integer> {
+
+    public static final long DEFAULT_TIMEOUT_MILLIS = 300L;
+    public static final long PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS = 1000L;
+
+    public RxIdentityProcessorTest() {
+        super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
+    }
+
+    @Override
+    public Processor<Integer, Integer> createIdentityProcessor(int bufferSize) {
+        return new SubjectProcessor<Integer, Integer>(PublishSubject.<Integer> create());
+    }
+
+    @Override
+    public long maxElementsFromPublisher() {
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public Publisher<Integer> createHelperPublisher(long elements) {
+        return RxReactiveStreams.<Integer>toPublisher(Observable.from(new IterableDecrementer(elements)));
+    }
+
+    @Override
+    public Publisher<Integer> createErrorStatePublisher() {
+        return RxReactiveStreams.<Integer>toPublisher(Observable.<Integer> error(new Exception("!")));
+    }
+
+}
diff --git a/src/test/java/rx/RxPublisherTest.java b/src/test/java/rx/RxPublisherTest.java
@@ -5,8 +5,7 @@
 import org.reactivestreams.tck.TestEnvironment;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
-import java.util.List;
+import rx.test.IterableDecrementer;
 
 @Test // needed for Gradle to find this as a test
 public class RxPublisherTest extends PublisherVerification<Integer> {
@@ -25,22 +24,12 @@ public long maxElementsFromPublisher() {
 
     @Override
     public Publisher<Integer> createPublisher(long elements) {
-        int elementsInt = (int) elements;
-        List<Integer> list = new ArrayList<Integer>(elementsInt);
-        for (int i = 0; i < elementsInt; i++) {
-            list.add(0);
-        }
-        return RxReactiveStreams.toPublisher(Observable.from(list));
+        return RxReactiveStreams.<Integer>toPublisher(Observable.from(new IterableDecrementer(elements)));
     }
 
     @Override
     public Publisher<Integer> createErrorStatePublisher() {
-        return RxReactiveStreams.toPublisher(Observable.create(new Observable.OnSubscribe<Integer>() {
-            @Override
-            public void call(Subscriber<? super Integer> subscriber) {
-                throw new RuntimeException("!");
-            }
-        }));
+        return RxReactiveStreams.<Integer>toPublisher(Observable.<Integer>error(new Exception("!")));
     }
 
 }
diff --git a/src/test/java/rx/RxSubscriberBlackboxTest.java b/src/test/java/rx/RxSubscriberBlackboxTest.java
@@ -0,0 +1,33 @@
+package rx;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.tck.SubscriberBlackboxVerification;
+import org.reactivestreams.tck.TestEnvironment;
+import org.testng.annotations.Test;
+
+import rx.internal.PublisherSubscriber;
+import rx.observers.EmptyObserver;
+import rx.observers.Subscribers;
+import rx.test.IterableDecrementer;
+
+@Test
+public class RxSubscriberBlackboxTest extends SubscriberBlackboxVerification<Integer> {
+
+    public static final long DEFAULT_TIMEOUT_MILLIS = 300L;
+
+    protected RxSubscriberBlackboxTest() {
+        super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS));
+    }
+
+    @Override
+    public Subscriber<Integer> createSubscriber() {
+        return new PublisherSubscriber<Integer>(Subscribers.from(new EmptyObserver<Integer>()));
+    }
+
+    @Override
+    public Publisher<Integer> createHelperPublisher(long elements) {
+        return RxReactiveStreams.<Integer>toPublisher(Observable.from(new IterableDecrementer(elements)));
+    }
+
+}
diff --git a/src/test/java/rx/RxSubscriberWhiteboxTest.java b/src/test/java/rx/RxSubscriberWhiteboxTest.java
@@ -0,0 +1,64 @@
+package rx;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import org.reactivestreams.tck.SubscriberWhiteboxVerification;
+import org.reactivestreams.tck.TestEnvironment;
+import org.testng.annotations.Test;
+
+import rx.internal.PublisherSubscriber;
+import rx.observers.EmptyObserver;
+import rx.observers.Subscribers;
+import rx.test.IterableDecrementer;
+
+@Test
+public class RxSubscriberWhiteboxTest extends SubscriberWhiteboxVerification<Integer> {
+
+    public static final long DEFAULT_TIMEOUT_MILLIS = 300L;
+
+    protected RxSubscriberWhiteboxTest() {
+        super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS));
+    }
+
+    @Override
+    public Subscriber<Integer> createSubscriber(final WhiteboxSubscriberProbe<Integer> probe) {
+        return new PublisherSubscriber<Integer>(Subscribers.from(new EmptyObserver<Integer>())) {
+            @Override
+            public void onSubscribe(final Subscription rsSubscription) {
+                probe.registerOnSubscribe(new SubscriberPuppet() {
+                    @Override
+                    public void triggerRequest(long elements) {
+                        rsSubscription.request(elements);
+                    }
+
+                    @Override
+                    public void signalCancel() {
+                        rsSubscription.cancel();
+                    }
+                });
+            }
+
+            @Override
+            public void onNext(Integer t) {
+                probe.registerOnNext(t);
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                probe.registerOnError(t);
+            }
+
+            @Override
+            public void onComplete() {
+                probe.registerOnComplete();
+            }
+        };
+    }
+
+    @Override
+    public Publisher<Integer> createHelperPublisher(long elements) {
+        return RxReactiveStreams.<Integer>toPublisher(Observable.from(new IterableDecrementer(elements)));
+    }
+
+}
diff --git a/src/test/java/rx/test/IterableDecrementer.java b/src/test/java/rx/test/IterableDecrementer.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package rx.test;
+
+import java.util.Iterator;
+
+/**
+ * Iterates from some arbitrary starting value down to 0, or forever if the starting value is
+ * Long.MAX_VALUE.
+ */
+public class IterableDecrementer implements Iterable<Integer> {
+
+    private final long from;
+
+    /**
+     * Creates new {@link IterableDecrementer}.
+     *
+     * @param from the value to start from. If equal to Long.MAX_VALUE, iteration never stops.
+     */
+    public IterableDecrementer(final long from) {
+        if (from < 0) {
+            throw new IllegalArgumentException("from < 0");
+        }
+        this.from = from;
+    }
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return new Repeater((int) from);
+    }
+
+    class Repeater implements Iterator<Integer> {
+
+        private int i;
+
+        public Repeater(final int repeats) {
+            i = repeats;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return i > 0 || from == Long.MAX_VALUE;
+        }
+
+        @Override
+        public Integer next() {
+            return --i;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+
+    }
+}