Fix tests after review. I've added special handling for cancellation token to the IsEquivalent() method

Author: ig-sinicyn

Gofer.NET.Tests/GivenATaskInfo.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -19,20 +20,23 @@ public void ItPersistsPropertiesWhenSerializedAndDeserialized()
             var taskInfos = new[] {
                 GetTestTask(() => TestMethod1("hello world")),
                 GetTestTask(() => TestMethod2()),
-                GetTestTask(() => TestMethod3(default))
+                GetTestTask(() => TestMethod3(new CancellationToken()))
             };
 
             foreach (var taskInfo in taskInfos)
             {
                 var serializedTaskInfo = JsonTaskInfoSerializer.Serialize(taskInfo);
                 var deserializedTaskInfo = JsonTaskInfoSerializer.Deserialize<TaskInfo>(serializedTaskInfo);
 
+                // we do skip cancellation tokens as they are ignored on serialization
+                var importantTaskArgs = taskInfo.Args.Select(a => a is CancellationToken ? null : a).ToArray();
+
                 deserializedTaskInfo.Id.Should().Be(taskInfo.Id);
                 deserializedTaskInfo.AssemblyName.Should().Be(taskInfo.AssemblyName);
                 deserializedTaskInfo.TypeName.Should().Be(taskInfo.TypeName);
                 deserializedTaskInfo.MethodName.Should().Be(taskInfo.MethodName);
                 deserializedTaskInfo.ReturnType.Should().Be(taskInfo.ReturnType);
-                deserializedTaskInfo.Args.ShouldAllBeEquivalentTo(taskInfo.Args);
+                deserializedTaskInfo.Args.ShouldAllBeEquivalentTo(importantTaskArgs);
                 deserializedTaskInfo.ArgTypes.ShouldAllBeEquivalentTo(taskInfo.ArgTypes);
                 deserializedTaskInfo.CreatedAtUtc.Should().Be(taskInfo.CreatedAtUtc);
 
@@ -50,7 +54,7 @@ public void ItProperlyDeterminesEquivalence()
             var taskInfo2a = GetTestTask(() => TestMethod2());
             var taskInfo2b = GetTestTask(() => TestMethod2());
 
-            var taskInfo3a = GetTestTask(() => TestMethod3(default));
+            var taskInfo3a = GetTestTask(() => TestMethod3(new CancellationToken()));
             var taskInfo3b = GetTestTask(() => TestMethod3(new CancellationTokenSource().Token));
 
             var taskInfo4a = GetTestTask(() => Console.WriteLine("hello"));

Gofer.NET.Utils/TaskInfo.cs

@@ -43,8 +43,12 @@ public bool IsEquivalent(TaskInfo otherTaskInfo)
                 return false;
             }
 
-            for (var i=0; i<Args.Length; ++i) {
-                if (!Equals(Args[i], otherTaskInfo.Args[i]))
+            for (var i = 0; i < Args.Length; ++i)
+            {
+                // comparison ignores cancellation tokens
+                // as they are ignored on serialization
+                // and will be replaced with proper value at invocation time
+                if (!Equals(GetEquivalenceArg(Args[i]), GetEquivalenceArg(otherTaskInfo.Args[i])))
                 {
                     return false;
                 }
@@ -56,26 +60,21 @@ public bool IsEquivalent(TaskInfo otherTaskInfo)
                 && ReturnType.Equals(otherTaskInfo.ReturnType);
         }
 
-        public void ConvertTypeArgs() 
+        private object GetEquivalenceArg(object value)
         {
-            for (var i=0;i<Args.Length;++i) {
-                if (Args[i] == null)
-                    continue;
-
-                if (typeof(Type).IsAssignableFrom(Args[i].GetType())) {
-                    Args[i] = new TypeWrapper {Type=(Type)Args[i]};
-                }
-            }
+            return value is CancellationToken ? null : value;
         }
 
-        public void UnconvertTypeArgs() 
+        public void UnconvertTypeArgs()
         {
-            for (var i=0;i<Args.Length;++i) {
+            for (var i = 0; i < Args.Length; ++i)
+            {
                 if (Args[i] == null)
                     continue;
-                    
-                if (typeof(TypeWrapper).IsAssignableFrom(Args[i].GetType())) {
-                    Args[i] = ((TypeWrapper) Args[i]).Type;
+
+                if (typeof(TypeWrapper).IsAssignableFrom(Args[i].GetType()))
+                {
+                    Args[i] = ((TypeWrapper)Args[i]).Type;
                 }
             }
         }