readme now up to date for jdk9

Author: ktoso

Diff for: tck-flow/README.md

@@ -5,8 +5,6 @@ and help Reactive Streams library implementers to validate their implementations
 
 Since this version of the TCK is intended to verify the interfaces contained in Java 9 (under `java.util.concurrent.Flow.*`), at least Java `9` is required to run this TCK. If you're looking for the previous TCK that was intended for Reactive Streams prior to their inclusion in the JDK please look at []
 
-The TCK is implemented using **plain Java (1.6)** and **TestNG** tests, and should be possible to use from other JVM-based languages and testing libraries.
-
 ## Structure of the TCK
 
 The TCK aims to cover all rules defined in the Specification, however for some rules outlined in the Specification it is
@@ -138,7 +136,7 @@ The expected behaviour from the returned implementation is to follow Rule 1.4 an
 with the order of emiting the `Subscription` and signaling the failure.
 
 ```java
-@Override public Publisher<T> createFailedPublisher() {
+@Override public Flow.Publisher<T> createFailedPublisher() {
   final String invalidData = "this input string is known it to be failed";
   return new MyPublisher(invalidData);
 }
@@ -157,24 +155,24 @@ In order to include it's tests in your test suite simply extend it, like this:
 ```java
 package com.example.streams;
 
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.tck.FlowPublisherVerification;
+import org.reactivestreams.tck.flow.FlowPublisherVerification;
 import org.reactivestreams.tck.TestEnvironment;
 
+import java.util.concurrent.Flow;
+
 public class RangePublisherTest extends FlowPublisherVerification<Integer> {
 
   public RangePublisherTest() {
     super(new TestEnvironment());
   }
 
   @Override
-  public Publisher<Integer> createPublisher(long elements) {
+  public Flow.Publisher<Integer> createPublisher(long elements) {
     return new RangePublisher<Integer>(1, elements);
   }
 
   @Override
-  public Publisher<Integer> createFailedPublisher() {
+  public Flow.Publisher<Integer> createFailedPublisher() {
     return new Publisher<Integer>() {
       @Override
       public void subscribe(Subscriber<Integer> s) {
@@ -187,7 +185,7 @@ public class RangePublisherTest extends FlowPublisherVerification<Integer> {
 
   @Override
   public long maxElementsFromPublisher() {
-    return Long.MAX_VALUE—1;
+    return Long.MAX_VALUE - 1;
   }
 
   @Override
@@ -258,7 +256,7 @@ The helper `Publisher` is an asynchronous `Publisher` by default—meaning that
 
 When extending `Subscriber` Verification classes a type parameter representing the element type passed through the stream must be given.
 Implementations are typically not sensitive to the type of element being signalled, but sometimes a `Subscriber` may be limited to only be able to work within a known set of types -
-like a `FileSubscriber extends Subscriber<ByteBuffer>` for example, that writes each element (ByteBuffer) it receives into a file.
+like a `FileSubscriber extends Flow.Subscriber<ByteBuffer>` for example, that writes each element (ByteBuffer) it receives into a file.
 For element type agnostic Subscribers the simplest way is to parameterize the tests using `Integer` and in the `createElement(int idx)` method (explained below in futher detail), return the incoming `int`. 
 In case an implementation needs to work on a specific type, the verification class should be parameterized using that type (e.g. `class StringSubTest extends FlowSubscriberWhiteboxVerification<String>`) and the `createElement` method must be overriden to return a `String`.
 
@@ -288,8 +286,8 @@ NOTE: The `createElement` method *MAY* be called *concurrently from multiple thr
 **Very advanced**: While it is not expected for many implementations having to do so, it is possible to take full control of the `Publisher` which will be driving the TCKs test. This can be achieved by implementing the `createHelperPublisher` method in which one can implement the `createHelperPublisher` method by returning a custom `Publisher` implementation which will then be used by the TCK to drive your `Subscriber` tests:
 
 ```java
-@Override public Publisher<Message> createHelperPublisher(long elements) {
-  return new Publisher<Message>() { /* CUSTOM IMPL HERE WHICH OF COURSE ALSO SHOULD PASS THE TCK */ };
+@Override public Flow.Publisher<Message> createHelperPublisher(long elements) {
+  return new Flow.Publisher<Message>() { /* CUSTOM IMPL HERE WHICH OF COURSE ALSO SHOULD PASS THE TCK */ };
 }
 ```
 
@@ -307,12 +305,11 @@ exteding (or delegating to) your implementation with additionally signalling and
 ```java
 package com.example.streams;
 
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-import org.reactivestreams.tck.FlowSubscriberWhiteboxVerification;
+import org.reactivestreams.tck.flow.FlowSubscriberWhiteboxVerification;
 import org.reactivestreams.tck.TestEnvironment;
 
+import java.util.concurrent.Flow;
+
 public class MyFlowSubscriberWhiteboxVerificationTest extends FlowSubscriberWhiteboxVerification<Integer> {
 
   public MyFlowSubscriberWhiteboxVerificationTest() {
@@ -323,12 +320,12 @@ public class MyFlowSubscriberWhiteboxVerificationTest extends FlowSubscriberWhit
   // class SyncSubscriber<T> extends Subscriber<T> { /* ... */ }
 
   @Override
-  public Subscriber<Integer> createSubscriber(final WhiteboxSubscriberProbe<Integer> probe) {
+  public Flow.Subscriber<Integer> createSubscriber(final WhiteboxSubscriberProbe<Integer> probe) {
     // in order to test the SyncSubscriber we must instrument it by extending it,
     // and calling the WhiteboxSubscriberProbe in all of the Subscribers methods:
     return new SyncSubscriber<Integer>() {
       @Override
-      public void onSubscribe(final Subscription s) {
+      public void onSubscribe(final Flow.Subscription s) {
         super.onSubscribe(s);
 
         // register a successful Subscription, and create a Puppet,
@@ -386,20 +383,19 @@ at the expense of not being able to verify as much as the `FlowSubscriberWhitebo
 ```java
 package com.example.streams;
 
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-import org.reactivestreams.tck.FlowSubscriberBlackboxVerification;
+import org.reactivestreams.tck.flow.FlowSubscriberBlackboxVerification;
 import org.reactivestreams.tck.TestEnvironment;
 
+import java.util.concurrent.Flow;
+
 public class MyFlowSubscriberBlackboxVerificationTest extends FlowSubscriberBlackboxVerification<Integer> {
 
   public MyFlowSubscriberBlackboxVerificationTest() {
     super(new TestEnvironment());
   }
 
   @Override
-  public Subscriber<Integer> createSubscriber() {
+  public Flow.Subscriber<Integer> createSubscriber() {
     return new MySubscriber<Integer>();
   }
 
@@ -451,14 +447,12 @@ An `IdentityFlowProcessorVerification` tests the given `Processor` for all `Subs
 ```java
 package com.example.streams;
 
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-import org.reactivestreams.tck.IdentityFlowProcessorVerification;
-import org.reactivestreams.tck.FlowSubscriberWhiteboxVerification;
+import org.reactivestreams.tck.flow.IdentityFlowProcessorVerification;
+import org.reactivestreams.tck.flow.FlowSubscriberWhiteboxVerification;
 import org.reactivestreams.tck.TestEnvironment;
 
+import java.util.concurrent.Flow;
+
 public class MyIdentityFlowProcessorVerificationTest extends IdentityFlowProcessorVerification<Integer> {
 
   public static final long DEFAULT_TIMEOUT_MILLIS = 300L;
@@ -470,19 +464,19 @@ public class MyIdentityFlowProcessorVerificationTest extends IdentityFlowProcess
   }
 
   @Override
-  public Processor<Integer, Integer> createIdentityProcessor(int bufferSize) {
+  public Flow.Processor<Integer, Integer> createIdentityProcessor(int bufferSize) {
     return new MyIdentityProcessor<Integer, Integer>(bufferSize);
   }
 
   @Override
-  public Publisher<Integer> createHelperPublisher(long elements) {
+  public Flow.Publisher<Integer> createHelperPublisher(long elements) {
     return new MyRangePublisher<Integer>(1, elements);
   }
 
   // ENABLE ADDITIONAL TESTS
 
   @Override
-  public Publisher<Integer> createFailedPublisher() {
+  public Flow.Publisher<Integer> createFailedPublisher() {
     // return Publisher that only signals onError instead of null to run additional tests
     // see this methods JavaDocs for more details on how the returned Publisher should work.
     return null;
@@ -517,15 +511,12 @@ cannot implement). Below is a recommended pattern to skip tests inherited from t
 ```java
 package com.example.streams;
 
-import org.reactivestreams.Processor;
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.reactivestreams.Subscription;
-import org.reactivestreams.tck.IdentityFlowProcessorVerification;
+import org.reactivestreams.tck.flow.IdentityFlowProcessorVerification;
 import org.reactivestreams.tck.TestEnvironment;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 
+import java.util.concurrent.Flow;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -554,12 +545,12 @@ public class MyIdentityProcessorTest extends IdentityFlowProcessorVerification<I
   }
 
   @Override
-  public Processor<Integer, Integer> createIdentityProcessor(int bufferSize) {
+  public Flow.Processor<Integer, Integer> createIdentityProcessor(int bufferSize) {
     return new MyProcessor<Integer, Integer>(bufferSize); // return implementation to be tested
   }
 
   @Override
-  public Publisher<Integer> createFailedPublisher() {
+  public Flow.Publisher<Integer> createFailedPublisher() {
     return null; // returning null means that the tests validating a failed publisher will be skipped
   }
 
@@ -606,12 +597,12 @@ class IterablePublisherTest(env: TestEnvironment, publisherShutdownTimeout: Long
     this(new TestEnvironment(500), 1000)
   }
 
-  def createPublisher(elements: Long): Publisher[Int] = ???
+  def createFlowPublisher(elements: Long): Flow.Publisher[Int] = ???
 
   // example error state publisher implementation
-  override def createFailedPublisher(): Publisher[Int] =
-    new Publisher[Int] {
-      override def subscribe(s: Subscriber[Int]): Unit =
+  override def createFailedFlowPublisher(): Flow.Publisher[Int] =
+    new Flow.Publisher[Int] {
+      override def subscribe(s: Flow.Subscriber[Int]): Unit =
         s.onError(new Exception("Unable to serve subscribers right now!"))
     }