Removes the Annotations.java from the TCK and replaces it with prefixing

TCK Verification methods with "required"/"optional"/"unverified"/"stochastic" instead.
This means that it is easy to change level by introducing a new method prefixed with
the updated requirement and deprecating the old method.

Author: viktorklang

tck/src/main/java/org/reactivestreams/tck/Annotations.java

@@ -12,8 +12,6 @@
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import static org.reactivestreams.tck.Annotations.NotVerified;
-import static org.reactivestreams.tck.Annotations.Required;
 import static org.reactivestreams.tck.SubscriberWhiteboxVerification.BlackboxSubscriberProxy;
 
 /**
@@ -68,8 +66,8 @@ public void setUp() throws Exception {
   ////////////////////// SPEC RULE VERIFICATION ///////////////////////////////
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.1
-  @Override @Required @Test
-  public void spec201_blackbox_mustSignalDemandViaSubscriptionRequest() throws Throwable {
+  @Override @Test
+  public void required___spec201_blackbox_mustSignalDemandViaSubscriptionRequest() throws Throwable {
     blackboxSubscriberTest(new BlackboxTestStageTestRun() {
       @Override
       public void run(BlackboxTestStage stage) throws InterruptedException {
@@ -83,14 +81,14 @@ public void run(BlackboxTestStage stage) throws InterruptedException {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.2
-  @Override @NotVerified @Test
-  public void spec202_blackbox_shouldAsynchronouslyDispatch() throws Exception {
+  @Override @Test
+  public void unverified___spec202_blackbox_shouldAsynchronouslyDispatch() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.3
-  @Override @Required @Test
-  public void spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete() throws Throwable {
+  @Override @Test
+  public void required___spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete() throws Throwable {
     blackboxSubscriberWithoutSetupTest(new BlackboxTestStageTestRun() {
       @Override
       public void run(BlackboxTestStage stage) throws Throwable {
@@ -126,8 +124,8 @@ public void cancel() {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.3
-  @Override @Required @Test
-  public void spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError() throws Throwable {
+  @Override @Test
+  public void required___spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError() throws Throwable {
     blackboxSubscriberWithoutSetupTest(new BlackboxTestStageTestRun() {
       @Override
       public void run(BlackboxTestStage stage) throws Throwable {
@@ -165,14 +163,14 @@ public void cancel() {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.4
-  @Override @NotVerified @Test
-  public void spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError() throws Exception {
+  @Override @Test
+  public void unverified___spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.5
-  @Override @Required @Test
-  public void spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal() throws Exception {
+  @Override @Test
+  public void required___spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal() throws Exception {
     new BlackboxTestStage(env) {{
       // try to subscribe another time, if the subscriber calls `probe.registerOnSubscribe` the test will fail
       final TestEnvironment.Latch secondSubscriptionCancelled = new TestEnvironment.Latch(env);
@@ -200,27 +198,27 @@ public String toString() {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.6
-  @Override @NotVerified @Test
-  public void spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid() throws Exception {
+  @Override @Test
+  public void unverified___spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.7
-  @Override @NotVerified @Test
-  public void spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization() throws Exception {
+  @Override @Test
+  public void unverified___spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
     // the same thread part of the clause can be verified but that is not very useful, or is it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.8
-  @Override @NotVerified @Test
-  public void spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel() throws Throwable {
+  @Override @Test
+  public void unverified___spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel() throws Throwable {
     notVerified(); // cannot be meaningfully tested as black box, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.9
-  @Override @Required @Test
-  public void spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall() throws Throwable {
+  @Override @Test
+  public void required___spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall() throws Throwable {
     blackboxSubscriberWithoutSetupTest(new BlackboxTestStageTestRun() {
       @Override
       public void run(BlackboxTestStage stage) throws Throwable {
@@ -239,8 +237,8 @@ public void run(BlackboxTestStage stage) throws Throwable {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.9
-  @Override @Required @Test
-  public void spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall() throws Throwable {
+  @Override @Test
+  public void required___spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall() throws Throwable {
     blackboxSubscriberWithoutSetupTest(new BlackboxTestStageTestRun() {
       @Override
       public void run(BlackboxTestStage stage) throws Throwable {
@@ -263,8 +261,8 @@ public void subscribe(Subscriber<? super T> s) {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.10
-  @Override @Required @Test
-  public void spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall() throws Throwable {
+  @Override @Test
+  public void required___spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall() throws Throwable {
     blackboxSubscriberTest(new BlackboxTestStageTestRun() {
       @Override
       @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
@@ -276,64 +274,64 @@ public void run(BlackboxTestStage stage) throws Throwable {
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.11
-  @Override @NotVerified @Test
-  public void spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents() throws Exception {
+  @Override @Test
+  public void unverified___spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.12
-  @Override @Required @Test
-  public void spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality() throws Throwable {
+  @Override @Test
+  public void required___spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality() throws Throwable {
     notVerified(); // cannot be meaningfully tested as black box, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#2.13
-  @Override @NotVerified @Test
-  public void spec213_blackbox_failingOnSignalInvocation() throws Exception {
+  @Override @Test
+  public void unverified___spec213_blackbox_failingOnSignalInvocation() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   ////////////////////// SUBSCRIPTION SPEC RULE VERIFICATION //////////////////
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.1
-  @Override @NotVerified @Test
-  public void spec301_blackbox_mustNotBeCalledOutsideSubscriberContext() throws Exception {
+  @Override @Test
+  public void unverified___spec301_blackbox_mustNotBeCalledOutsideSubscriberContext() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.8
-  @Override @Required @Test
-  public void spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced() throws Throwable {
+  @Override @Test
+  public void required___spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced() throws Throwable {
     notVerified(); // cannot be meaningfully tested as black box, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.10
-  @Override @NotVerified @Test
-  public void spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber() throws Exception {
+  @Override @Test
+  public void unverified___spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.11
-  @Override @NotVerified @Test
-  public void spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError() throws Exception {
+  @Override @Test
+  public void unverified___spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.14
-  @Override @NotVerified @Test
-  public void spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists() throws Exception {
+  @Override @Test
+  public void unverified___spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.15
-  @Override @NotVerified @Test
-  public void spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError() throws Exception {
+  @Override @Test
+  public void unverified___spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.16
-  @Override @NotVerified @Test
-  public void spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber() throws Exception {
+  @Override @Test
+  public void unverified___spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber() throws Exception {
     notVerified(); // cannot be meaningfully tested, or can it?
   }