Skip §2.13 for value types (#34)

Author: Marc Piechura

src/examples/Reactive.Streams.Example.Unicast.Tests/SyncSubscriberWhiteboxTest.cs

@@ -5,9 +5,72 @@
 namespace Reactive.Streams.Example.Unicast.Tests
 {
     [TestFixture]
-    public class SyncSubscriberWhiteboxTest : SubscriberWhiteboxVerification<int?>
+    public class ValueTypeSyncSubscriberWhiteboxTest : SubscriberWhiteboxVerification<int>
     {
-        public SyncSubscriberWhiteboxTest() : base(new TestEnvironment())
+        public ValueTypeSyncSubscriberWhiteboxTest() : base(new TestEnvironment())
+        {
+        }
+
+        public override int CreateElement(int element) => element;
+
+        public override ISubscriber<int> CreateSubscriber(WhiteboxSubscriberProbe<int> probe) => new Subscriber(probe);
+
+        private sealed class Subscriber : SyncSubscriber<int>
+        {
+            private readonly WhiteboxSubscriberProbe<int> _probe;
+
+            public Subscriber(WhiteboxSubscriberProbe<int> probe)
+            {
+                _probe = probe;
+            }
+
+            public override void OnSubscribe(ISubscription subscription)
+            {
+                base.OnSubscribe(subscription);
+
+                _probe.RegisterOnSubscribe(new SubscriberPuppet(subscription));
+            }
+
+            private sealed class SubscriberPuppet : ISubscriberPuppet
+            {
+                private readonly ISubscription _subscription;
+
+                public SubscriberPuppet(ISubscription subscription)
+                {
+                    _subscription = subscription;
+                }
+
+                public void TriggerRequest(long elements) => _subscription.Request(elements);
+
+                public void SignalCancel() => _subscription.Cancel();
+            }
+
+            public override void OnNext(int element)
+            {
+                base.OnNext(element);
+                _probe.RegisterOnNext(element);
+            }
+
+            protected override bool WhenNext(int element) => true;
+
+            public override void OnError(Exception cause)
+            {
+                base.OnError(cause);
+                _probe.RegisterOnError(cause);
+            }
+
+            public override void OnComplete()
+            {
+                base.OnComplete();
+                _probe.RegisterOnComplete();
+            }
+        }
+    }
+
+    [TestFixture]
+    public class NullableSyncSubscriberWhiteboxTest : SubscriberWhiteboxVerification<int?>
+    {
+        public NullableSyncSubscriberWhiteboxTest() : base(new TestEnvironment())
         {
         }
 

src/tck/Reactive.Streams.TCK.Tests/SubscriberBlackboxVerificationTest.cs

@@ -115,6 +115,12 @@ public void Required_spec213_blackbox_mustThrowNullPointerExceptionWhenParameter
                 () => CustomSubscriberVerification(new LamdaSubscriber<int?>()).Required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull(),
                 "OnNext(null) did not throw ArgumentNullException");
 
+        [Test]
+        public void Required_spec213_blackbox_mustThrowNullPointerExceptionWhenParametersAreNull_mustIgnoreSpecForValueType_onNext()
+            => RequireTestSkip(
+                () => SimpleSubscriberVerification().Required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull(),
+                "Can't verify behavior for value types");
+
         [Test]
         public void Required_spec213_blackbox_mustThrowNullPointerExceptionWhenParametersAreNull_mustFailOnIgnoredNull_onError()
             => RequireTestFailure(

src/tck/Reactive.Streams.TCK/SubscriberBlackboxVerification.cs

@@ -310,15 +310,17 @@ public void Required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionW
         public void Required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull()
             => BlackboxSubscriberWithoutSetupTest(stage =>
             {
+                var element = default(T);
+                if(element != null)
+                    throw new IgnoreException("Can't verify behavior for value types");
+
                 var subscriber = CreateSubscriber();
                 var gotNpe = false;
                 subscriber.OnSubscribe(new Spec213DummySubscription());
 
                 try
                 {
-                    // we can't use null here because we can't enforce a constsraint which supports Nullable<T>
-                    // default(T) will return null for all reference types as well as Nullable<T>
-                    subscriber.OnNext(default(T));
+                    subscriber.OnNext(element);
                 }
                 catch (ArgumentNullException)
                 {

src/tck/Reactive.Streams.TCK/SubscriberWhiteboxVerification.cs

@@ -329,13 +329,15 @@ public void Required_spec213_onSubscribe_mustThrowNullPointerExceptionWhenParame
         public void Required_spec213_onNext_mustThrowNullPointerExceptionWhenParametersAreNull()
             => SubscriberTest(stage =>
             {
+                var element = default(T);
+                if (element != null)
+                    throw new IgnoreException("Can't verify behavior for value types");
+
                 var subscriber = stage.Sub;
                 var gotNpe = false;
                 try
                 {
-                    // we can't use null here because we can't enforce a constsraint which supports Nullable<T>
-                    // default(T) will return null for all reference types as well as Nullable<T>
-                    subscriber.OnNext(default(T));
+                    subscriber.OnNext(element);
                 }
                 catch (ArgumentNullException)
                 {