Get tests to build/ported over to xUnit

Ix.NET/Source/System.Interactive.Async.Providers/project.json

@@ -63,7 +63,9 @@
                 "System.Linq": "4.0.0",
                 "System.Linq.Expressions": "4.0.0",
                 "System.Linq.Queryable": "4.0.0",
-                "System.Reflection": "4.0.0"
+                "System.Reflection": "4.0.0",
+                "System.Runtime": "4.0.0",
+                "System.Runtime.Extensions": "4.0.0"
             }
 
         },

Ix.NET/Source/System.Interactive.Async/project.json

@@ -58,7 +58,9 @@
             },
             "dependencies": {
                 "System.Linq": "4.0.0",
-                "System.Threading": "4.0.0"
+                "System.Threading": "4.0.0",
+                "System.Runtime": "4.0.0",
+                "System.Runtime.Extensions": "4.0.0"
             }
             
         },

Ix.NET/Source/System.Interactive.Providers/project.json

@@ -63,7 +63,9 @@
                 "System.Linq": "4.0.0",
                 "System.Linq.Expressions": "4.0.0",
                 "System.Linq.Queryable": "4.0.0",
-                "System.Reflection": "4.0.0"
+                "System.Reflection": "4.0.0",
+                "System.Runtime": "4.0.0",
+                "System.Runtime.Extensions": "4.0.0"
             }
 
         },

Ix.NET/Source/System.Interactive/project.json

@@ -58,7 +58,9 @@
             },
             "dependencies": {
                 "System.Linq": "4.0.0",
-                "System.Threading" : "4.0.0" 
+                "System.Threading": "4.0.0",
+                "System.Runtime": "4.0.0",
+                "System.Runtime.Extensions": "4.0.0"
             }
 
         },

Ix.NET/Source/Tests/AssertEx.cs

@@ -1,5 +1,5 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System;
 
 namespace Tests
@@ -23,12 +23,12 @@ namespace Tests
             }
             catch (T ex)
             {
-                Assert.IsTrue(assert(ex));
+                Assert.True(assert(ex));
 
                 failed = true;
             }
 
-            Assert.IsTrue(failed);
+            Assert.True(failed);
         }
 
         internal static void SucceedOrFailProper(Action action)

Ix.NET/Source/Tests/AsyncQueryableTests.Generated.tt

@@ -103,11 +103,11 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
-	[TestClass]
+	
 	public class AsyncQueryableTests
 	{
 <#
@@ -252,7 +252,7 @@ foreach (var m in typeof(AsyncEnumerable).GetMethods()
 
 	testName += (num + 1);
 #>
-		[TestMethod]
+		[Fact]
 		public void <#=testName#>()
 		{
 <#

Ix.NET/Source/Tests/AsyncTests.Bugs.cs

@@ -4,7 +4,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Collections;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,8 +14,7 @@ namespace Tests
 {
     public partial class AsyncTests
     {
-        [TestInitialize]
-        public void InitTests()
+        public AsyncTests()
         {
             TaskScheduler.UnobservedTaskException += (o, e) =>
             {
@@ -23,7 +22,7 @@ namespace Tests
         }
 
         /*
-        [TestMethod]
+        [Fact]
         public void TestPushPopAsync()
         {
             var stack = new Stack<int>();
@@ -42,7 +41,7 @@ namespace Tests
             // we give it a timeout so the test can fail instead of hang
             task.Wait(TimeSpan.FromSeconds(2));
 
-            Assert.AreEqual(10, stack.Count);
+            Assert.Equal(10, stack.Count);
         }
 
         private Task DoSomethingAsync(IObservable<int> observable, Stack<int> stack)
@@ -77,7 +76,7 @@ namespace Tests
             return tcs.Task;
         }
         */
-
+#if !NO_THREAD
         static IEnumerable<int> Xs(Action a)
         {
             try
@@ -95,8 +94,9 @@ namespace Tests
                 a();
             }
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void CorrectDispose()
         {
             var disposed = new TaskCompletionSource<bool>();
@@ -111,12 +111,12 @@ namespace Tests
             var e = ys.GetEnumerator();
             e.Dispose();
 
-            Assert.IsTrue(disposed.Task.Result);
+            Assert.True(disposed.Task.Result);
 
-            Assert.IsFalse(e.MoveNext().Result);
+            Assert.False(e.MoveNext().Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void DisposesUponError()
         {
             var disposed = new TaskCompletionSource<bool>();
@@ -132,10 +132,10 @@ namespace Tests
             var e = ys.GetEnumerator();
             AssertThrows<Exception>(() => e.MoveNext().Wait());
 
-            Assert.IsTrue(disposed.Task.Result);
+            Assert.True(disposed.Task.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void CorrectCancel()
         {
             var disposed = new TaskCompletionSource<bool>();
@@ -169,13 +169,13 @@ namespace Tests
                 // it. This design is chosen because cancelling a MoveNext call leaves
                 // the enumerator in an indeterminate state. Further interactions with
                 // it should be forbidden.
-                Assert.IsTrue(disposed.Task.Result);
+                Assert.True(disposed.Task.Result);
             }
 
-            Assert.IsFalse(e.MoveNext().Result);
+            Assert.False(e.MoveNext().Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void CanCancelMoveNext()
         {
             var evt = new ManualResetEvent(false);
@@ -190,11 +190,11 @@ namespace Tests
             try
             {
                 t.Wait();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch
             {
-                Assert.IsTrue(t.IsCanceled);
+                Assert.True(t.IsCanceled);
             }
 
             evt.Set();
@@ -206,7 +206,7 @@ namespace Tests
             yield return 42;
         }
 
-        [TestMethod]
+        [Fact]
         public void TakeOneFromSelectMany()
         {
             var enumerable = AsyncEnumerable
@@ -215,29 +215,29 @@ namespace Tests
                 .Take(1)
                 .Do(_ => { });
 
-            Assert.AreEqual("Check", enumerable.First().Result);
+            Assert.Equal("Check", enumerable.First().Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SelectManyDisposeInvokedOnlyOnce()
         {
             var disposeCounter = new DisposeCounter();
 
             var result = AsyncEnumerable.Return(1).SelectMany(i => disposeCounter).Select(i => i).ToList().Result;
 
-            Assert.AreEqual(0, result.Count);
-            Assert.AreEqual(1, disposeCounter.DisposeCount);
+            Assert.Equal(0, result.Count);
+            Assert.Equal(1, disposeCounter.DisposeCount);
         }
 
-        [TestMethod]
+        [Fact]
         public void SelectManyInnerDispose()
         {
             var disposes = Enumerable.Range(0, 10).Select(_ => new DisposeCounter()).ToList();
 
             var result = AsyncEnumerable.Range(0, 10).SelectMany(i => disposes[i]).Select(i => i).ToList().Result;
 
-            Assert.AreEqual(0, result.Count);
-            Assert.IsTrue(disposes.All(d => d.DisposeCount == 1));
+            Assert.Equal(0, result.Count);
+            Assert.True(disposes.All(d => d.DisposeCount == 1));
         }
 
         private class DisposeCounter : IAsyncEnumerable<object>

Ix.NET/Source/Tests/AsyncTests.Conversions.cs

@@ -5,21 +5,21 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Threading;
 
 namespace Tests
 {
     public partial class AsyncTests
     {
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable<int>(default(IEnumerable<int>)));
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToAsyncEnumerable<int>(default(IObservable<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -31,7 +31,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable2()
         {
             var ex = new Exception("Bang");
@@ -47,7 +47,7 @@ namespace Tests
             throw e;
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable3()
         {
             var subscribed = false;
@@ -62,17 +62,17 @@ namespace Tests
                 return new MyDisposable(() => { });
             }).ToAsyncEnumerable();
 
-            Assert.IsFalse(subscribed);
+            Assert.False(subscribed);
 
             var e = xs.GetEnumerator();
 
-            Assert.IsTrue(subscribed);
+            Assert.True(subscribed);
 
             HasNext(e, 42);
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable4()
         {
             var ex = new Exception("Bang!");
@@ -87,16 +87,16 @@ namespace Tests
                 return new MyDisposable(() => { });
             }).ToAsyncEnumerable();
 
-            Assert.IsFalse(subscribed);
+            Assert.False(subscribed);
 
             var e = xs.GetEnumerator();
 
-            Assert.IsTrue(subscribed);
+            Assert.True(subscribed);
 
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable_With_Completed_Task()
         {
             var task = Task.Factory.StartNew(() => 36);
@@ -104,12 +104,12 @@ namespace Tests
             var xs = task.ToAsyncEnumerable();
             var e = xs.GetEnumerator();
 
-            Assert.IsTrue(e.MoveNext().Result);
-            Assert.AreEqual(36, e.Current);
-            Assert.IsFalse(e.MoveNext().Result);
+            Assert.True(e.MoveNext().Result);
+            Assert.Equal(36, e.Current);
+            Assert.False(e.MoveNext().Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable_With_Faulted_Task()
         {
             var ex = new InvalidOperationException();
@@ -122,7 +122,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToAsyncEnumerable_With_Canceled_Task()
         {
             var tcs = new TaskCompletionSource<int>();
@@ -164,27 +164,27 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToEnumerable<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable1()
         {
             var xs = AsyncEnumerable.Return(42).ToEnumerable();
-            Assert.IsTrue(xs.SequenceEqual(new[] { 42 }));
+            Assert.True(xs.SequenceEqual(new[] { 42 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable2()
         {
             var xs = AsyncEnumerable.Empty<int>().ToEnumerable();
-            Assert.IsTrue(xs.SequenceEqual(new int[0]));
+            Assert.True(xs.SequenceEqual(new int[0]));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable3()
         {
             var ex = new Exception("Bang");
@@ -193,13 +193,13 @@ namespace Tests
         }
 
 #if !NO_RXINTERFACES
-        [TestMethod]
+        [Fact]
         public void ToObservable_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.ToObservable<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable1()
         {
             var fail = false;
@@ -223,10 +223,10 @@ namespace Tests
             ));
 
             evt.WaitOne();
-            Assert.IsFalse(fail);
+            Assert.False(fail);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable2()
         {
             var lst = new List<int>();
@@ -251,11 +251,11 @@ namespace Tests
             ));
 
             evt.WaitOne();
-            Assert.IsFalse(fail);
-            Assert.IsTrue(lst.SequenceEqual(new[] { 42 }));
+            Assert.False(fail);
+            Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable3()
         {
             var lst = new List<int>();
@@ -280,11 +280,11 @@ namespace Tests
             ));
 
             evt.WaitOne();
-            Assert.IsFalse(fail);
-            Assert.IsTrue(lst.SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.False(fail);
+            Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable4()
         {
             var ex1 = new Exception("Bang!");
@@ -311,8 +311,8 @@ namespace Tests
             ));
 
             evt.WaitOne();
-            Assert.IsFalse(fail);
-            Assert.AreEqual(ex1, ((AggregateException)ex_).InnerExceptions.Single());
+            Assert.False(fail);
+            Assert.Equal(ex1, ((AggregateException)ex_).InnerExceptions.Single());
         }
 
         class MyObserver<T> : IObserver<T>

Ix.NET/Source/Tests/AsyncTests.Creation.cs

@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Threading.Tasks;
 using System.Threading;
 
@@ -21,48 +21,48 @@ namespace Tests
 
     public partial class AsyncTests
     {
-        [TestMethod]
+        [Fact]
         public void Return()
         {
             var xs = AsyncEnumerable.Return(42);
             HasNext(xs.GetEnumerator(), 42);
         }
 
-        [TestMethod]
+        [Fact]
         public void Never()
         {
             var xs = AsyncEnumerable.Never<int>();
 
             var e = xs.GetEnumerator();
-            Assert.IsFalse(e.MoveNext().IsCompleted); // Very rudimentary check
+            Assert.False(e.MoveNext().IsCompleted); // Very rudimentary check
             AssertThrows<InvalidOperationException>(() => Nop(e.Current));
             e.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void Empty1()
         {
             var xs = AsyncEnumerable.Empty<int>();
             NoNext(xs.GetEnumerator());
         }
 
-        [TestMethod]
+        [Fact]
         public void Empty2()
         {
             var xs = AsyncEnumerable.Empty<int>();
 
             var e = xs.GetEnumerator();
-            Assert.IsFalse(e.MoveNext().Result);
+            Assert.False(e.MoveNext().Result);
             AssertThrows<InvalidOperationException>(() => Nop(e.Current));
         }
 
-        [TestMethod]
+        [Fact]
         public void Throw_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Throw<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Throw()
         {
             var ex = new Exception("Bang");
@@ -77,13 +77,13 @@ namespace Tests
         {
         }
 
-        [TestMethod]
+        [Fact]
         public void Range_Null()
         {
             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Range(0, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void Range1()
         {
             var xs = AsyncEnumerable.Range(2, 5);
@@ -97,7 +97,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Range2()
         {
             var xs = AsyncEnumerable.Range(2, 0);
@@ -106,13 +106,13 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Repeat_Null()
         {
             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Repeat(0, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void Repeat1()
         {
             var xs = AsyncEnumerable.Repeat(2, 5);
@@ -126,7 +126,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Repeat2()
         {
             var xs = AsyncEnumerable.Repeat(2, 0);
@@ -135,7 +135,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Repeat3()
         {
             var xs = AsyncEnumerable.Repeat(2);
@@ -149,13 +149,13 @@ namespace Tests
             e.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void Defer_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Defer<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Defer1()
         {
             var x = 0;
@@ -175,7 +175,7 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Generate<int, int>(0, null, x => x, x => x));
@@ -183,7 +183,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Generate<int, int>(0, x => true, x => x, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate1()
         {
             var xs = AsyncEnumerable.Generate(0, x => x < 5, x => x + 1, x => x * x);
@@ -198,7 +198,7 @@ namespace Tests
             e.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate2()
         {
             var ex = new Exception("Bang!");
@@ -208,7 +208,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate3()
         {
             var ex = new Exception("Bang!");
@@ -219,7 +219,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate4()
         {
             var ex = new Exception("Bang!");
@@ -230,14 +230,14 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Using<int, IDisposable>(null, _ => null));
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Using<int, IDisposable>(() => new MyD(null), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Using1()
         {
             var i = 0;
@@ -252,13 +252,13 @@ namespace Tests
                 _ => AsyncEnumerable.Return(42)
             );
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
             var e = xs.GetEnumerator();
-            Assert.AreEqual(1, i);
+            Assert.Equal(1, i);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using2()
         {
             var i = 0;
@@ -273,16 +273,16 @@ namespace Tests
                 _ => AsyncEnumerable.Return(42)
             );
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
             var e = xs.GetEnumerator();
-            Assert.AreEqual(1, i);
+            Assert.Equal(1, i);
 
             e.Dispose();
-            Assert.AreEqual(1, d);
+            Assert.Equal(1, d);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using3()
         {
             var ex = new Exception("Bang!");
@@ -298,14 +298,14 @@ namespace Tests
                 _ => { throw ex; }
             );
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
             AssertThrows<Exception>(() => xs.GetEnumerator(), ex_ => ex_ == ex);
             
-            Assert.AreEqual(1, d);
+            Assert.Equal(1, d);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using4()
         {
             var i = 0;
@@ -320,18 +320,18 @@ namespace Tests
                 _ => AsyncEnumerable.Return(42)
             );
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
             var e = xs.GetEnumerator();
-            Assert.AreEqual(1, i);
+            Assert.Equal(1, i);
 
             HasNext(e, 42);
             NoNext(e);
 
-            Assert.IsTrue(disposed.Task.Result);
+            Assert.True(disposed.Task.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using5()
         {
             var ex = new Exception("Bang!");
@@ -347,17 +347,17 @@ namespace Tests
                 _ => AsyncEnumerable.Throw<int>(ex)
             );
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
             var e = xs.GetEnumerator();
-            Assert.AreEqual(1, i);
+            Assert.Equal(1, i);
 
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
 
-            Assert.IsTrue(disposed.Task.Result);
+            Assert.True(disposed.Task.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using6()
         {
             var i = 0;
@@ -372,10 +372,10 @@ namespace Tests
                 _ => AsyncEnumerable.Range(0, 10)
             );
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
             var e = xs.GetEnumerator();
-            Assert.AreEqual(1, i);
+            Assert.Equal(1, i);
 
             HasNext(e, 0);
             HasNext(e, 1);
@@ -393,7 +393,7 @@ namespace Tests
                 ex.Flatten().Handle(inner => inner is TaskCanceledException);
             }
 
-            Assert.IsTrue(disposed.Task.Result);
+            Assert.True(disposed.Task.Result);
         }
 
         class MyD : IDisposable

Ix.NET/Source/Tests/AsyncTests.Exceptions.cs

@@ -5,14 +5,14 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Threading;
 
 namespace Tests
 {
     public partial class AsyncTests
     {
-        [TestMethod]
+        [Fact]
         public void Catch_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Catch<int, Exception>(default(IAsyncEnumerable<int>), x => null));
@@ -24,7 +24,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Catch<int>(default(IEnumerable<IAsyncEnumerable<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch1()
         {
             var err = false;
@@ -39,10 +39,10 @@ namespace Tests
             HasNext(e, 3);
             NoNext(e);
 
-            Assert.IsFalse(err);
+            Assert.False(err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch2()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -58,18 +58,18 @@ namespace Tests
             HasNext(e, 2);
             HasNext(e, 3);
 
-            Assert.IsFalse(err);
+            Assert.False(err);
 
             HasNext(e, 4);
 
-            Assert.IsTrue(err);
+            Assert.True(err);
 
             HasNext(e, 5);
             HasNext(e, 6);
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch3()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -85,18 +85,18 @@ namespace Tests
             HasNext(e, 2);
             HasNext(e, 3);
 
-            Assert.IsFalse(err);
+            Assert.False(err);
 
             HasNext(e, 4);
 
-            Assert.IsTrue(err);
+            Assert.True(err);
 
             HasNext(e, 5);
             HasNext(e, 6);
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch4()
         {
             var ex = new DivideByZeroException();
@@ -114,10 +114,10 @@ namespace Tests
 
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
 
-            Assert.IsFalse(err);
+            Assert.False(err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch5()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -136,7 +136,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch6()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -151,11 +151,11 @@ namespace Tests
             HasNext(e, 2);
             HasNext(e, 3);
 
-            Assert.IsFalse(err);
+            Assert.False(err);
 
             HasNext(e, 1);
 
-            Assert.IsTrue(err);
+            Assert.True(err);
 
             HasNext(e, 2);
             HasNext(e, 3);
@@ -163,7 +163,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch7()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -178,7 +178,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch8()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -198,7 +198,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch9()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -221,7 +221,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch10()
         {
             var res = CatchXss().Catch();
@@ -240,7 +240,7 @@ namespace Tests
             throw new Exception("Bang!");
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch11()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -260,7 +260,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch12()
         {
             var res = AsyncEnumerable.Catch(Enumerable.Empty<IAsyncEnumerable<int>>());
@@ -269,14 +269,14 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Finally(default(IAsyncEnumerable<int>), () => { }));
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Finally(AsyncEnumerable.Return(42), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally1()
         {
             var b = false;
@@ -285,13 +285,13 @@ namespace Tests
 
             var e = xs.GetEnumerator();
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             NoNext(e);
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally2()
         {
             var b = false;
@@ -300,16 +300,16 @@ namespace Tests
 
             var e = xs.GetEnumerator();
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             HasNext(e, 42);
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             NoNext(e);
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally3()
         {
             var ex = new Exception("Bang!");
@@ -320,13 +320,13 @@ namespace Tests
 
             var e = xs.GetEnumerator();
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally4()
         {
             var b = false;
@@ -335,19 +335,19 @@ namespace Tests
 
             var e = xs.GetEnumerator();
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             HasNext(e, 1);
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             HasNext(e, 2);
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             NoNext(e);
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally5()
         {
             var b = false;
@@ -356,15 +356,15 @@ namespace Tests
 
             var e = xs.GetEnumerator();
 
-            Assert.IsFalse(b);
+            Assert.False(b);
             HasNext(e, 1);
 
             e.Dispose();
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        //[TestMethod]
+        //[Fact]
         public void Finally6()
         {
             var b = false;
@@ -379,10 +379,10 @@ namespace Tests
             cts.Cancel();
             t.Wait();
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OnErrorResumeNext<int>(default(IAsyncEnumerable<int>), AsyncEnumerable.Return(42)));
@@ -391,7 +391,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.OnErrorResumeNext<int>(default(IEnumerable<IAsyncEnumerable<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext7()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -409,7 +409,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext8()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -429,7 +429,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext9()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -455,7 +455,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext10()
         {
             var res = OnErrorResumeNextXss().OnErrorResumeNext();
@@ -474,7 +474,7 @@ namespace Tests
             throw new Exception("Bang!");
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext11()
         {
             var ex = new InvalidOperationException("Bang!");
@@ -493,7 +493,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext12()
         {
             var res = AsyncEnumerable.OnErrorResumeNext(Enumerable.Empty<IAsyncEnumerable<int>>());
@@ -502,7 +502,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Retry<int>(default(IAsyncEnumerable<int>)));
@@ -511,7 +511,7 @@ namespace Tests
             AssertThrows<ArgumentOutOfRangeException>(() => AsyncEnumerable.Retry<int>(AsyncEnumerable.Return(42), -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -525,7 +525,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry2()
         {
             var ex = new InvalidOperationException("Bang!");

Ix.NET/Source/Tests/AsyncTests.Multiple.cs

@@ -5,14 +5,14 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Threading;
 
 namespace Tests
 {
     public partial class AsyncTests
     {
-        [TestMethod]
+        [Fact]
         public void Concat_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(null, AsyncEnumerable.Return(42)));
@@ -21,7 +21,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Concat<int>(default(IEnumerable<IAsyncEnumerable<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat1()
         {
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().Concat(new[] { 4, 5, 6 }.ToAsyncEnumerable());
@@ -36,7 +36,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat2()
         {
             var ex = new Exception("Bang");
@@ -49,7 +49,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat3()
         {
             var ex = new Exception("Bang");
@@ -59,7 +59,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat4()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -80,7 +80,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat5()
         {
             var ex = new Exception("Bang");
@@ -99,7 +99,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat6()
         {
             var res = AsyncEnumerable.Concat(ConcatXss());
@@ -120,7 +120,7 @@ namespace Tests
             throw new Exception("Bang!");
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(null, AsyncEnumerable.Return(42), (x, y) => x + y));
@@ -128,7 +128,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Zip<int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -142,7 +142,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip2()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -156,7 +156,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip3()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -170,7 +170,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip4()
         {
             var ex = new Exception("Bang!");
@@ -182,7 +182,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip5()
         {
             var ex = new Exception("Bang!");
@@ -194,7 +194,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Zip6()
         {
             var ex = new Exception("Bang!");
@@ -206,7 +206,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Union_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(null, AsyncEnumerable.Return(42)));
@@ -217,7 +217,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Union<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Union1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -233,7 +233,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Union2()
         {
             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
@@ -249,7 +249,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Intersect_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(null, AsyncEnumerable.Return(42)));
@@ -260,7 +260,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Intersect<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Intersect1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -273,7 +273,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Intersect2()
         {
             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
@@ -286,7 +286,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Except_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(null, AsyncEnumerable.Return(42)));
@@ -297,7 +297,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Except<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Except1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
@@ -309,7 +309,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Except2()
         {
             var xs = new[] { 1, 2, -3 }.ToAsyncEnumerable();
@@ -321,7 +321,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(null, AsyncEnumerable.Return(42)));
@@ -339,50 +339,50 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SequenceEqual<int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), null, CancellationToken.None));
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual1()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(xs);
-            Assert.IsTrue(res.Result);
+            Assert.True(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual2()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.SequenceEqual(xs);
-            Assert.IsTrue(res.Result);
+            Assert.True(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual3()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
-            Assert.IsFalse(res.Result);
+            Assert.False(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual4()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
-            Assert.IsFalse(res.Result);
+            Assert.False(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual5()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys);
-            Assert.IsFalse(res.Result);
+            Assert.False(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual6()
         {
             var ex = new Exception("Bang!");
@@ -393,7 +393,7 @@ namespace Tests
             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual7()
         {
             var ex = new Exception("Bang!");
@@ -404,50 +404,50 @@ namespace Tests
             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual8()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(xs, new Eq());
-            Assert.IsTrue(res.Result);
+            Assert.True(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual9()
         {
             var xs = AsyncEnumerable.Empty<int>();
             var res = xs.SequenceEqual(xs, new Eq());
-            Assert.IsTrue(res.Result);
+            Assert.True(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual10()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 3, 2 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.IsFalse(res.Result);
+            Assert.False(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual11()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.IsFalse(res.Result);
+            Assert.False(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual12()
         {
             var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable();
             var ys = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.IsFalse(res.Result);
+            Assert.False(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual13()
         {
             var ex = new Exception("Bang!");
@@ -458,7 +458,7 @@ namespace Tests
             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual14()
         {
             var ex = new Exception("Bang!");
@@ -469,16 +469,16 @@ namespace Tests
             AssertThrows<Exception>(() => res.Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual15()
         {
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
             var ys = new[] { 1, -2, 3, 4 }.ToAsyncEnumerable();
             var res = xs.SequenceEqual(ys, new Eq());
-            Assert.IsTrue(res.Result);
+            Assert.True(res.Result);
         }
 
-        [TestMethod]
+        [Fact]
         public void SequenceEqual16()
         {
             var xs = new[] { 1, 2, -3, 4 }.ToAsyncEnumerable();
@@ -500,7 +500,7 @@ namespace Tests
             }
         }
         
-        [TestMethod]
+        [Fact]
         public void GroupJoin_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x));
@@ -517,7 +517,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.GroupJoin<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin1()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -532,7 +532,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin2()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -547,7 +547,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin3()
         {
             var ex = new Exception("Bang!");
@@ -560,7 +560,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin4()
         {
             var ex = new Exception("Bang!");
@@ -573,7 +573,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin5()
         {
             var ex = new Exception("Bang!");
@@ -586,7 +586,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin6()
         {
             var ex = new Exception("Bang!");
@@ -599,7 +599,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void GroupJoin7()
         {
             var ex = new Exception("Bang!");
@@ -617,7 +617,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(null, AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x));
@@ -634,7 +634,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.Join<int, int, int, int>(AsyncEnumerable.Return(42), AsyncEnumerable.Return(42), x => x, x => x, (x, y) => x, default(IEqualityComparer<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Join1()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -649,7 +649,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join2()
         {
             var xs = new[] { 3, 6, 4 }.ToAsyncEnumerable();
@@ -664,7 +664,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join3()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
@@ -678,7 +678,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join4()
         {
             var xs = new[] { 3, 6 }.ToAsyncEnumerable();
@@ -692,7 +692,7 @@ namespace Tests
             NoNext(e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join5()
         {
             var ex = new Exception("Bang!");
@@ -705,7 +705,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join6()
         {
             var ex = new Exception("Bang!");
@@ -718,7 +718,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join7()
         {
             var ex = new Exception("Bang!");
@@ -731,7 +731,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join8()
         {
             var ex = new Exception("Bang!");
@@ -744,7 +744,7 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void Join9()
         {
             var ex = new Exception("Bang!");
@@ -757,14 +757,14 @@ namespace Tests
             AssertThrows<Exception>(() => e.MoveNext().Wait(), ex_ => ((AggregateException)ex_).Flatten().InnerExceptions.Single() == ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void SelectManyMultiple_Null()
         {
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(default(IAsyncEnumerable<int>), AsyncEnumerable.Return(42)));
             AssertThrows<ArgumentNullException>(() => AsyncEnumerable.SelectMany<int, int>(AsyncEnumerable.Return(42), default(IAsyncEnumerable<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void SelectManyMultiple1()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();

Ix.NET/Source/Tests/AsyncTests.cs

@@ -4,36 +4,23 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
-    [TestClass]
+    
     public partial class AsyncTests
     {
         public void AssertThrows<E>(Action a)
             where E : Exception
         {
-            var hasFailed = false;
-
-            try
-            {
-                a();
-            }
-            catch (E)
-            {
-                hasFailed = true;
-            }
-
-            if (!hasFailed)
-            {
-                Assert.Fail();
-            }
+            Assert.Throws<E>(a);
         }
 
         public void AssertThrows<E>(Action a, Func<E, bool> assert)
             where E : Exception
         {
+
             var hasFailed = false;
 
             try
@@ -42,25 +29,25 @@ namespace Tests
             }
             catch (E e)
             {
-                Assert.IsTrue(assert(e));
+                Assert.True(assert(e));
                 hasFailed = true;
             }
 
             if (!hasFailed)
             {
-                Assert.Fail();
+                Assert.True(false);
             }
         }
 
         public void NoNext<T>(IAsyncEnumerator<T> e)
         {
-            Assert.IsFalse(e.MoveNext().Result);
+            Assert.False(e.MoveNext().Result);
         }
 
         public void HasNext<T>(IAsyncEnumerator<T> e, T value)
         {
-            Assert.IsTrue(e.MoveNext().Result);
-            Assert.AreEqual(value, e.Current);
+            Assert.True(e.MoveNext().Result);
+            Assert.Equal(value, e.Current);
         }
     }
 }

Ix.NET/Source/Tests/TaskExtTests.cs

@@ -1,6 +1,6 @@
 namespace Tests
 {
-    using Microsoft.VisualStudio.TestTools.UnitTesting;
+    using Xunit;
     using System;
     using System.Collections.Generic;
     using System.Linq;
@@ -8,7 +8,7 @@
 
     public partial class AsyncTests
     {
-        [TestMethod]
+        [Fact]
         public async Task ExceptionHandling_ShouldThrowUnwrappedException()
         {
             try
@@ -18,7 +18,7 @@
             }
             catch (AggregateException)
             {
-                Assert.Fail("AggregateException has been thrown instead of InvalidOperationException");
+                Assert.True(false, "AggregateException has been thrown instead of InvalidOperationException");
             }
             catch (InvalidOperationException)
             {
@@ -31,7 +31,7 @@
             throw new InvalidOperationException();
         }
 
-        [TestMethod]
+        [Fact]
         public async Task ExceptionHandling_ShouldThrowUnwrappedException2()
         {
             try
@@ -41,7 +41,7 @@
             }
             catch (AggregateException)
             {
-                Assert.Fail("AggregateException has been thrown instead of InvalidOperationException");
+                Assert.True(false, "AggregateException has been thrown instead of InvalidOperationException");
             }
             catch (InvalidOperationException)
             {

Ix.NET/Source/Tests/Tests.Aggregates.cs

@@ -3,41 +3,41 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void IsEmtpy_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.IsEmpty<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void IsEmpty_Empty()
         {
-            Assert.IsTrue(Enumerable.Empty<int>().IsEmpty());
+            Assert.True(Enumerable.Empty<int>().IsEmpty());
         }
 
-        [TestMethod]
+        [Fact]
         public void IsEmpty_NonEmpty()
         {
-            Assert.IsFalse(new[] { 1 }.IsEmpty());
+            Assert.False(new[] { 1 }.IsEmpty());
         }
 
-        [TestMethod]
+        [Fact]
         public void Min_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Min(null, Comparer<int>.Default));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Min(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Min()
         {
-            Assert.AreEqual(3, new[] { 5, 3, 7 }.Min(new Mod3Comparer()));
+            Assert.Equal(3, new[] { 5, 3, 7 }.Min(new Mod3Comparer()));
         }
 
         class Mod3Comparer : IComparer<int>
@@ -48,7 +48,7 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void MinBy_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.MinBy(null, (int x) => x));
@@ -58,30 +58,30 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.MinBy(new[] { 1 }, (int x) => x, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void MinBy()
         {
             var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MinBy(x => x % 3);
-            Assert.IsTrue(res.SequenceEqual(new[] { 0, 3, 6 }));
+            Assert.True(res.SequenceEqual(new[] { 0, 3, 6 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void MinBy_Empty()
         {
             AssertThrows<InvalidOperationException>(() => Enumerable.Empty<int>().MinBy(x => x));
         }
 
-        [TestMethod]
+        [Fact]
         public void Max_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Max(null, Comparer<int>.Default));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Max(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Max()
         {
-            Assert.AreEqual(5, new[] { 2, 5, 3, 7 }.Max(new Mod7Comparer()));
+            Assert.Equal(5, new[] { 2, 5, 3, 7 }.Max(new Mod7Comparer()));
         }
 
         class Mod7Comparer : IComparer<int>
@@ -92,7 +92,7 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void MaxBy_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.MaxBy(null, (int x) => x));
@@ -102,14 +102,14 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.MaxBy(new[] { 1 }, (int x) => x, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void MaxBy()
         {
             var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MaxBy(x => x % 3);
-            Assert.IsTrue(res.SequenceEqual(new[] { 2, 5, 2 }));
+            Assert.True(res.SequenceEqual(new[] { 2, 5, 2 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void MaxBy_Empty()
         {
             AssertThrows<InvalidOperationException>(() => Enumerable.Empty<int>().MaxBy(x => x));

Ix.NET/Source/Tests/Tests.Buffering.cs

@@ -3,20 +3,20 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Collections;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void Share_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Share<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Share1()
         {
             var rng = Enumerable.Range(0, 5).Share();
@@ -30,7 +30,7 @@ namespace Tests
             NoNext(e1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Share2()
         {
             var rng = Enumerable.Range(0, 5).Share();
@@ -46,7 +46,7 @@ namespace Tests
             NoNext(e1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Share3()
         {
             var rng = Enumerable.Range(0, 5).Share();
@@ -63,7 +63,7 @@ namespace Tests
             NoNext(e1);
         }
 
-        //[TestMethod]
+        //[Fact]
         public void Share4()
         {
             var rng = Enumerable.Range(0, 5).Share();
@@ -74,10 +74,10 @@ namespace Tests
             HasNext(e1, 2);
 
             e1.Dispose();
-            Assert.IsFalse(e1.MoveNext());
+            Assert.False(e1.MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void Share5()
         {
             var rng = Enumerable.Range(0, 5).Share();
@@ -93,23 +93,23 @@ namespace Tests
             AssertThrows<ObjectDisposedException>(() => ((IEnumerable)rng).GetEnumerator());
         }
 
-        [TestMethod]
+        [Fact]
         public void Share6()
         {
             var rng = Enumerable.Range(0, 5).Share();
 
             var e1 = ((IEnumerable)rng).GetEnumerator();
-            Assert.IsTrue(e1.MoveNext());
-            Assert.AreEqual(0, (int)e1.Current);
+            Assert.True(e1.MoveNext());
+            Assert.Equal(0, (int)e1.Current);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Publish<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish0()
         {
             var n = 0;
@@ -119,30 +119,30 @@ namespace Tests
             var e2 = rng.GetEnumerator();
 
             HasNext(e1, 0);
-            Assert.AreEqual(0, n);
+            Assert.Equal(0, n);
 
             HasNext(e1, 1);
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
 
             HasNext(e1, 2);
-            Assert.AreEqual(3, n);
+            Assert.Equal(3, n);
             HasNext(e2, 0);
-            Assert.AreEqual(3, n);
+            Assert.Equal(3, n);
 
             HasNext(e1, 3);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
             HasNext(e2, 1);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
 
             HasNext(e2, 2);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
             HasNext(e2, 3);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
 
             HasNext(e2, 4);
-            Assert.AreEqual(10, n);
+            Assert.Equal(10, n);
             HasNext(e1, 4);
-            Assert.AreEqual(10, n);
+            Assert.Equal(10, n);
         }
 
         static IEnumerable<int> Tick(Action<int> t)
@@ -155,7 +155,7 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish1()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -169,7 +169,7 @@ namespace Tests
             NoNext(e1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish2()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -190,7 +190,7 @@ namespace Tests
             NoNext(e2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish3()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -211,7 +211,7 @@ namespace Tests
             NoNext(e2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish4()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -229,7 +229,7 @@ namespace Tests
             NoNext(e2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish5()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -246,7 +246,7 @@ namespace Tests
             NoNext(e2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish6()
         {
             var ex = new MyException();
@@ -267,7 +267,7 @@ namespace Tests
         {
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish7()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -290,7 +290,7 @@ namespace Tests
             NoNext(e3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish8()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -306,30 +306,30 @@ namespace Tests
             AssertThrows<ObjectDisposedException>(() => ((IEnumerable)rng).GetEnumerator());
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish9()
         {
             var rng = Enumerable.Range(0, 5).Publish();
 
             var e1 = ((IEnumerable)rng).GetEnumerator();
-            Assert.IsTrue(e1.MoveNext());
-            Assert.AreEqual(0, (int)e1.Current);
+            Assert.True(e1.MoveNext());
+            Assert.Equal(0, (int)e1.Current);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish10()
         {
             var rnd = Rand().Take(1000).Publish();
-            Assert.IsTrue(rnd.Zip(rnd, (l, r) => l == r).All(x => x));
+            Assert.True(rnd.Zip(rnd, (l, r) => l == r).All(x => x));
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void MemoizeLimited_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int>(null, 2));
@@ -337,7 +337,7 @@ namespace Tests
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Memoize<int>(new[] { 1 }, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize0()
         {
             var n = 0;
@@ -347,33 +347,33 @@ namespace Tests
             var e2 = rng.GetEnumerator();
 
             HasNext(e1, 0);
-            Assert.AreEqual(0, n);
+            Assert.Equal(0, n);
 
             HasNext(e1, 1);
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
 
             HasNext(e1, 2);
-            Assert.AreEqual(3, n);
+            Assert.Equal(3, n);
             HasNext(e2, 0);
-            Assert.AreEqual(3, n);
+            Assert.Equal(3, n);
 
             HasNext(e1, 3);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
             HasNext(e2, 1);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
 
             HasNext(e2, 2);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
             HasNext(e2, 3);
-            Assert.AreEqual(6, n);
+            Assert.Equal(6, n);
 
             HasNext(e2, 4);
-            Assert.AreEqual(10, n);
+            Assert.Equal(10, n);
             HasNext(e1, 4);
-            Assert.AreEqual(10, n);
+            Assert.Equal(10, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish11()
         {
             var rng = Enumerable.Range(0, 5).Publish();
@@ -395,7 +395,7 @@ namespace Tests
             NoNext(e3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize1()
         {
             var rng = Enumerable.Range(0, 5).Memoize();
@@ -409,7 +409,7 @@ namespace Tests
             NoNext(e1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize2()
         {
             var rng = Enumerable.Range(0, 5).Memoize();
@@ -431,7 +431,7 @@ namespace Tests
             NoNext(e2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize3()
         {
             var rng = Enumerable.Range(0, 5).Memoize();
@@ -454,7 +454,7 @@ namespace Tests
             NoNext(e2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize4()
         {
             var rng = Enumerable.Range(0, 5).Memoize(2);
@@ -473,7 +473,7 @@ namespace Tests
             AssertThrows<InvalidOperationException>(() => e3.MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize6()
         {
             var ex = new MyException();
@@ -490,7 +490,7 @@ namespace Tests
             AssertThrows<MyException>(() => e2.MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize7()
         {
             var rng = Enumerable.Range(0, 5).Memoize();
@@ -515,7 +515,7 @@ namespace Tests
             NoNext(e3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize8()
         {
             var rng = Enumerable.Range(0, 5).Memoize();
@@ -531,21 +531,21 @@ namespace Tests
             AssertThrows<ObjectDisposedException>(() => ((IEnumerable)rng).GetEnumerator());
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize9()
         {
             var rng = Enumerable.Range(0, 5).Memoize();
 
             var e1 = ((IEnumerable)rng).GetEnumerator();
-            Assert.IsTrue(e1.MoveNext());
-            Assert.AreEqual(0, (int)e1.Current);
+            Assert.True(e1.MoveNext());
+            Assert.Equal(0, (int)e1.Current);
         }
 
-        [TestMethod]
+        [Fact]
         public void Memoize10()
         {
             var rnd = Rand().Take(1000).Memoize();
-            Assert.IsTrue(rnd.Zip(rnd, (l, r) => l == r).All(x => x));
+            Assert.True(rnd.Zip(rnd, (l, r) => l == r).All(x => x));
         }
 
         static Random s_rand = new Random();
@@ -556,55 +556,55 @@ namespace Tests
                 yield return s_rand.Next();
         }
 
-        [TestMethod]
+        [Fact]
         public void ShareLambda_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Share<int, int>(null, xs => xs));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Share<int, int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ShareLambda()
         {
             var n = 0;
             var res = Enumerable.Range(0, 10).Do(_ => n++).Share(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList();
-            Assert.IsTrue(res.SequenceEqual(new[] { 0 + 1, 2 + 3, 4 + 5, 6 + 7 }));
-            Assert.AreEqual(8, n);
+            Assert.True(res.SequenceEqual(new[] { 0 + 1, 2 + 3, 4 + 5, 6 + 7 }));
+            Assert.Equal(8, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLambda_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Publish<int, int>(null, xs => xs));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Publish<int, int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLambda()
         {
             var n = 0;
             var res = Enumerable.Range(0, 10).Do(_ => n++).Publish(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList();
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
-            Assert.AreEqual(4, n);
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
+            Assert.Equal(4, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void MemoizeLambda_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(null, xs => xs));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void MemoizeLambda()
         {
             var n = 0;
             var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList();
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
-            Assert.AreEqual(4, n);
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
+            Assert.Equal(4, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void MemoizeLimitedLambda_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Memoize<int, int>(null, 2, xs => xs));
@@ -613,13 +613,13 @@ namespace Tests
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Memoize<int, int>(new[] { 1 }, -1, xs => xs));
         }
 
-        [TestMethod]
+        [Fact]
         public void MemoizeLimitedLambda()
         {
             var n = 0;
             var res = Enumerable.Range(0, 10).Do(_ => n++).Memoize(2, xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList();
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
-            Assert.AreEqual(4, n);
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 4).Select(x => x * 2)));
+            Assert.Equal(4, n);
         }
     }
 }

Ix.NET/Source/Tests/Tests.Creation.cs

@@ -3,20 +3,20 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Collections;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void Create_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Create<int>(default(Func<IEnumerator<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Create1()
         {
             var hot = false;
@@ -26,10 +26,10 @@ namespace Tests
                 return MyEnumerator();
             });
 
-            Assert.IsFalse(hot);
+            Assert.False(hot);
 
             var e = res.GetEnumerator();
-            Assert.IsTrue(hot);
+            Assert.True(hot);
 
             HasNext(e, 1);
             HasNext(e, 2);
@@ -37,11 +37,11 @@ namespace Tests
 
             hot = false;
             var f = ((IEnumerable)res).GetEnumerator();
-            Assert.IsTrue(hot);
+            Assert.True(hot);
         }
 
 #if HAS_AWAIT
-        [TestMethod]
+        [Fact]
         public void CreateYield()
         {
             var xs = EnumerableEx.Create<int>(async yield => {
@@ -55,14 +55,14 @@ namespace Tests
             int j = 0;
             foreach (int elem in xs)
             {
-                Assert.AreEqual(elem, j);
+                Assert.Equal(elem, j);
                 j++;
             }
 
-            Assert.AreEqual(j, 10);
+            Assert.Equal(j, 10);
         }
 
-        [TestMethod]
+        [Fact]
         public void CreateYieldBreak()
         {
             var xs = EnumerableEx.Create<int>(async yield => {
@@ -82,14 +82,14 @@ namespace Tests
             int j = 0;
             foreach (int elem in xs)
             {
-                Assert.AreEqual(elem, j);
+                Assert.Equal(elem, j);
                 j++;
             }
 
-            Assert.AreEqual(j, 10);
+            Assert.Equal(j, 10);
         }
 
-        [TestMethod]
+        [Fact]
         public void YielderNoReset()
         {
             var xs = EnumerableEx.Create<int>(async yield => {
@@ -106,19 +106,19 @@ namespace Tests
             yield return 2;
         }
 
-        [TestMethod]
+        [Fact]
         public void Return()
         {
-            Assert.AreEqual(42, EnumerableEx.Return(42).Single());
+            Assert.Equal(42, EnumerableEx.Return(42).Single());
         }
 
-        [TestMethod]
+        [Fact]
         public void Throw_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Throw<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Throw()
         {
             var ex = new MyException();
@@ -128,13 +128,13 @@ namespace Tests
             AssertThrows<MyException>(() => e.MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void Defer_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Defer<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Defer1()
         {
             var i = 0;
@@ -145,17 +145,17 @@ namespace Tests
                 return Enumerable.Range(0, n);
             });
 
-            Assert.AreEqual(0, i);
+            Assert.Equal(0, i);
 
-            Assert.IsTrue(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n)));
-            Assert.AreEqual(1, i);
+            Assert.True(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n)));
+            Assert.Equal(1, i);
 
             n = 3;
-            Assert.IsTrue(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n)));
-            Assert.AreEqual(2, i);
+            Assert.True(Enumerable.SequenceEqual(xs, Enumerable.Range(0, n)));
+            Assert.Equal(2, i);
         }
 
-        [TestMethod]
+        [Fact]
         public void Defer2()
         {
             var xs = EnumerableEx.Defer<int>(() =>
@@ -166,7 +166,7 @@ namespace Tests
             AssertThrows<MyException>(() => xs.GetEnumerator().MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Generate<int, int>(0, null, _ => _, _ => _));
@@ -174,61 +174,61 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Generate<int, int>(0, _ => true, _ => _, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Generate()
         {
             var res = EnumerableEx.Generate(0, x => x < 5, x => x + 1, x => x * x).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0, 1, 4, 9, 16 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 0, 1, 4, 9, 16 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Using_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Using<int, MyDisposable>(null, d => new[] { 1 }));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Using<int, MyDisposable>(() => new MyDisposable(), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Using1()
         {
             var d = default(MyDisposable);
 
             var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => new[] { 1 });
-            Assert.IsNull(d);
+            Assert.Null(d);
 
             var d1 = default(MyDisposable);
-            xs.ForEach(_ => { d1 = d; Assert.IsNotNull(d1); Assert.IsFalse(d1.Done); });
-            Assert.IsTrue(d1.Done);
+            xs.ForEach(_ => { d1 = d; Assert.NotNull(d1); Assert.False(d1.Done); });
+            Assert.True(d1.Done);
 
             var d2 = default(MyDisposable);
-            xs.ForEach(_ => { d2 = d; Assert.IsNotNull(d2); Assert.IsFalse(d2.Done); });
-            Assert.IsTrue(d2.Done);
+            xs.ForEach(_ => { d2 = d; Assert.NotNull(d2); Assert.False(d2.Done); });
+            Assert.True(d2.Done);
 
-            Assert.AreNotSame(d1, d2);
+            Assert.NotSame(d1, d2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using2()
         {
             var d = default(MyDisposable);
 
             var xs = EnumerableEx.Using(() => d = new MyDisposable(), d_ => EnumerableEx.Throw<int>(new MyException()));
-            Assert.IsNull(d);
+            Assert.Null(d);
 
             AssertThrows<MyException>(() => xs.ForEach(_ => { }));
-            Assert.IsTrue(d.Done);
+            Assert.True(d.Done);
         }
 
-        [TestMethod]
+        [Fact]
         public void Using3()
         {
             var d = default(MyDisposable);
 
             var xs = EnumerableEx.Using<int, MyDisposable>(() => d = new MyDisposable(), d_ => { throw new MyException(); });
-            Assert.IsNull(d);
+            Assert.Null(d);
 
             AssertThrows<MyException>(() => xs.ForEach(_ => { }));
-            Assert.IsTrue(d.Done);
+            Assert.True(d.Done);
         }
 
         class MyDisposable : IDisposable
@@ -241,15 +241,15 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void RepeatElementInfinite()
         {
             var xs = EnumerableEx.Repeat(42).Take(1000);
-            Assert.IsTrue(xs.All(x => x == 42));
-            Assert.IsTrue(xs.Count() == 1000);
+            Assert.True(xs.All(x => x == 42));
+            Assert.True(xs.Count() == 1000);
         }
 
-        [TestMethod]
+        [Fact]
         public void RepeatSequence_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Repeat<int>(null));
@@ -257,28 +257,28 @@ namespace Tests
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Repeat<int>(new[] { 1 }, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void RepeatSequence1()
         {
             var i = 0;
             var xs = new[] { 1, 2 }.Do(_ => i++).Repeat();
 
             var res = xs.Take(10).ToList();
-            Assert.AreEqual(10, res.Count);
-            Assert.IsTrue(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3));
-            Assert.AreEqual(10, i);
+            Assert.Equal(10, res.Count);
+            Assert.True(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3));
+            Assert.Equal(10, i);
         }
 
-        [TestMethod]
+        [Fact]
         public void RepeatSequence2()
         {
             var i = 0;
             var xs = new[] { 1, 2 }.Do(_ => i++).Repeat(5);
 
             var res = xs.ToList();
-            Assert.AreEqual(10, res.Count);
-            Assert.IsTrue(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3));
-            Assert.AreEqual(10, i);
+            Assert.Equal(10, res.Count);
+            Assert.True(res.Buffer(2).Select(b => b.Sum()).All(x => x == 3));
+            Assert.Equal(10, i);
         }
     }
 }

Ix.NET/Source/Tests/Tests.Exceptions.cs

@@ -3,13 +3,13 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void Catch_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Catch<int>(null, new[] { 1 }));
@@ -20,89 +20,89 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Catch<int, Exception>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch1()
         {
             var ex = new MyException();
-            var res = EnumerableEx.Throw<int>(ex).Catch<int, MyException>(e => { Assert.AreSame(ex, e); return new[] { 42 }; }).Single();
-            Assert.AreEqual(42, res);
+            var res = EnumerableEx.Throw<int>(ex).Catch<int, MyException>(e => { Assert.Same(ex, e); return new[] { 42 }; }).Single();
+            Assert.Equal(42, res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch2()
         {
             var ex = new MyException();
-            var res = EnumerableEx.Throw<int>(ex).Catch<int, Exception>(e => { Assert.AreSame(ex, e); return new[] { 42 }; }).Single();
-            Assert.AreEqual(42, res);
+            var res = EnumerableEx.Throw<int>(ex).Catch<int, Exception>(e => { Assert.Same(ex, e); return new[] { 42 }; }).Single();
+            Assert.Equal(42, res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch3()
         {
             var ex = new MyException();
             AssertThrows<MyException>(() =>
             {
-                EnumerableEx.Throw<int>(ex).Catch<int, InvalidOperationException>(e => { Assert.Fail(); return new[] { 42 }; }).Single();
+                EnumerableEx.Throw<int>(ex).Catch<int, InvalidOperationException>(e => { Assert.True(false); return new[] { 42 }; }).Single();
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch4()
         {
             var xs = Enumerable.Range(0, 10);
-            var res = xs.Catch<int, MyException>(e => { Assert.Fail(); return new[] { 42 }; });
-            Assert.IsTrue(xs.SequenceEqual(res));
+            var res = xs.Catch<int, MyException>(e => { Assert.True(false); return new[] { 42 }; });
+            Assert.True(xs.SequenceEqual(res));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch5()
         {
             var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) };
             var res = EnumerableEx.Catch(xss);
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 5)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch6()
         {
             var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) };
             var res = xss.Catch();
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 5)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch7()
         {
             var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) };
             var res = xss[0].Catch(xss[1]);
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 5)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 5)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch8()
         {
             var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw<int>(new MyException())), Enumerable.Range(5, 5) };
             var res = EnumerableEx.Catch(xss);
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch9()
         {
             var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw<int>(new MyException())), Enumerable.Range(5, 5) };
             var res = xss.Catch();
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch10()
         {
             var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw<int>(new MyException())), Enumerable.Range(5, 5) };
             var res = xss[0].Catch(xss[1]);
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch11()
         {
             var e1 = new MyException();
@@ -125,78 +125,78 @@ namespace Tests
             AssertThrows<MyException>(() => e.MoveNext(), ex => ex == e3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Finally<int>(null, () => { }));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Finally<int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally1()
         {
             var done = false;
 
             var xs = Enumerable.Range(0, 2).Finally(() => done = true);
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             var e = xs.GetEnumerator();
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             HasNext(e, 0);
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             HasNext(e, 1);
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             NoNext(e);
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally2()
         {
             var done = false;
 
             var xs = Enumerable.Range(0, 2).Finally(() => done = true);
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             var e = xs.GetEnumerator();
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             HasNext(e, 0);
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             e.Dispose();
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void Finally3()
         {
             var done = false;
 
             var ex = new MyException();
             var xs = EnumerableEx.Throw<int>(ex).Finally(() => done = true);
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             var e = xs.GetEnumerator();
-            Assert.IsFalse(done);
+            Assert.False(done);
 
             try
             {
                 HasNext(e, 0);
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (MyException ex_)
             {
-                Assert.AreSame(ex, ex_);
+                Assert.Same(ex, ex_);
             }
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(null, new[] { 1 }));
@@ -205,27 +205,27 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.OnErrorResumeNext<int>(default(IEnumerable<IEnumerable<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext1()
         {
             var xs = new[] { 1, 2 };
             var ys = new[] { 3, 4 };
 
             var res = xs.OnErrorResumeNext(ys);
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext2()
         {
             var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
             var ys = new[] { 3, 4 };
 
             var res = xs.OnErrorResumeNext(ys);
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext3()
         {
             var xs = new[] { 1, 2 };
@@ -233,10 +233,10 @@ namespace Tests
             var zs = new[] { 5, 6 };
 
             var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext4()
         {
             var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
@@ -244,30 +244,30 @@ namespace Tests
             var zs = new[] { 5, 6 };
 
             var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext5()
         {
             var xs = new[] { 1, 2 };
             var ys = new[] { 3, 4 };
 
             var res = new[] { xs, ys }.OnErrorResumeNext();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnErrorResumeNext6()
         {
             var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
             var ys = new[] { 3, 4 };
 
             var res = new[] { xs, ys }.OnErrorResumeNext();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Retry<int>(null));
@@ -275,25 +275,25 @@ namespace Tests
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Retry<int>(new[] { 1 }, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry1()
         {
             var xs = Enumerable.Range(0, 10);
 
             var res = xs.Retry();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, xs));
+            Assert.True(Enumerable.SequenceEqual(res, xs));
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry2()
         {
             var xs = Enumerable.Range(0, 10);
 
             var res = xs.Retry(2);
-            Assert.IsTrue(Enumerable.SequenceEqual(res, xs));
+            Assert.True(Enumerable.SequenceEqual(res, xs));
         }
 
-        [TestMethod]
+        [Fact]
         public void Retry3()
         {
             var ex = new MyException();

Ix.NET/Source/Tests/Tests.Imperative.cs

@@ -3,59 +3,59 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void While_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.While<int>(null, new[] { 1 }));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.While<int>(() => true, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void While1()
         {
             var x = 5;
             var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void While2()
         {
             var x = 0;
             var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new int[0]));
+            Assert.True(Enumerable.SequenceEqual(res, new int[0]));
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.DoWhile<int>(new[] { 1 }, null));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.DoWhile<int>(null, () => true));
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile1()
         {
             var x = 5;
             var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile2()
         {
             var x = 0;
             var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 0 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.If<int>(null, new[] { 1 }));
@@ -65,31 +65,31 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.If<int>(() => true, new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void If1()
         {
             var x = 5;
             var res = EnumerableEx.If(() => x > 0, new[] { +1 }, new[] { -1 });
 
-            Assert.AreEqual(+1, res.Single());
+            Assert.Equal(+1, res.Single());
 
             x = -x;
-            Assert.AreEqual(-1, res.Single());
+            Assert.Equal(-1, res.Single());
         }
 
-        [TestMethod]
+        [Fact]
         public void If2()
         {
             var x = 5;
             var res = EnumerableEx.If(() => x > 0, new[] { +1 });
 
-            Assert.AreEqual(+1, res.Single());
+            Assert.Equal(+1, res.Single());
 
             x = -x;
-            Assert.IsTrue(res.IsEmpty());
+            Assert.True(res.IsEmpty());
         }
 
-        [TestMethod]
+        [Fact]
         public void Case_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Case<int, int>(null, new Dictionary<int, IEnumerable<int>>()));
@@ -99,7 +99,7 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Case<int, int>(() => 1, new Dictionary<int, IEnumerable<int>>(), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Case1()
         {
             var x = 1;
@@ -112,26 +112,26 @@ namespace Tests
                 { 3, EnumerableEx.Defer(() => new[] { d }) },
             });
 
-            Assert.AreEqual('b', res.Single());
-            Assert.AreEqual('b', res.Single());
+            Assert.Equal('b', res.Single());
+            Assert.Equal('b', res.Single());
 
             x = 0;
-            Assert.AreEqual('a', res.Single());
+            Assert.Equal('a', res.Single());
 
             x = 2;
-            Assert.AreEqual('c', res.Single());
+            Assert.Equal('c', res.Single());
 
             x = 3;
-            Assert.AreEqual('d', res.Single());
+            Assert.Equal('d', res.Single());
 
             d = 'e';
-            Assert.AreEqual('e', res.Single());
+            Assert.Equal('e', res.Single());
 
             x = 4;
-            Assert.IsTrue(res.IsEmpty());
+            Assert.True(res.IsEmpty());
         }
 
-        [TestMethod]
+        [Fact]
         public void Case2()
         {
             var x = 1;
@@ -144,37 +144,37 @@ namespace Tests
                 { 3, EnumerableEx.Defer(() => new[] { d }) },
             }, new[] { 'z' });
 
-            Assert.AreEqual('b', res.Single());
-            Assert.AreEqual('b', res.Single());
+            Assert.Equal('b', res.Single());
+            Assert.Equal('b', res.Single());
 
             x = 0;
-            Assert.AreEqual('a', res.Single());
+            Assert.Equal('a', res.Single());
 
             x = 2;
-            Assert.AreEqual('c', res.Single());
+            Assert.Equal('c', res.Single());
 
             x = 3;
-            Assert.AreEqual('d', res.Single());
+            Assert.Equal('d', res.Single());
 
             d = 'e';
-            Assert.AreEqual('e', res.Single());
+            Assert.Equal('e', res.Single());
 
             x = 4;
-            Assert.AreEqual('z', res.Single());
+            Assert.Equal('z', res.Single());
         }
 
-        [TestMethod]
+        [Fact]
         public void For_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.For<int, int>(null, x => new[] { 1 }));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.For<int, int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void For()
         {
             var res = EnumerableEx.For(new[] { 1, 2, 3 }, x => Enumerable.Range(0, x)).ToList();
-            Assert.IsTrue(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2 }));
+            Assert.True(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2 }));
         }
     }
 }

Ix.NET/Source/Tests/Tests.Multiple.cs

@@ -3,20 +3,20 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void Concat_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Concat(default(IEnumerable<int>[])));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Concat(default(IEnumerable<IEnumerable<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat1()
         {
             var res = new[]
@@ -25,10 +25,10 @@ namespace Tests
                 new[] { 4, 5 }
             }.Concat();
 
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat2()
         {
             var i = 0;
@@ -36,7 +36,7 @@ namespace Tests
 
             var res = xss.Concat().Select(x => i + " - " + x).ToList();
 
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 
                 "1 - 0",
                 "2 - 0",
                 "2 - 1",
@@ -46,7 +46,7 @@ namespace Tests
             }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Concat3()
         {
             var res = EnumerableEx.Concat(
@@ -54,21 +54,21 @@ namespace Tests
                 new[] { 4, 5 }
             );
 
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void SelectMany_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.SelectMany<int, int>(null, new[] { 1 }));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.SelectMany<int, int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void SelectMany()
         {
             var res = new[] { 1, 2 }.SelectMany(new[] { 'a', 'b', 'c' }).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 'a', 'b', 'c', 'a', 'b', 'c' }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 'a', 'b', 'c', 'a', 'b', 'c' }));
         }
     }
 }

Ix.NET/Source/Tests/Tests.Qbservable.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Reflection;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Runtime.CompilerServices;
 using System.Linq.Expressions;
 using System.ComponentModel;
@@ -15,17 +15,17 @@ namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void Queryable_Enumerable_Parity()
         {
-            var enu = typeof(EnumerableEx).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList();
-            var qry = typeof(QueryableEx).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList();
+            var enu = typeof(EnumerableEx).GetRuntimeMethods().Where(m => m.IsStatic && m.IsPublic).ToList();
+            var qry = typeof(QueryableEx).GetRuntimeMethods().Where(m => m.IsStatic && m.IsPublic).ToList();
 
             var onlyInObs = enu.Select(m => m.Name).Except(qry.Select(m => m.Name)).Except(new[] { "ForEach", "ToEnumerable", "Multicast", "GetAwaiter", "ToEvent", "ToEventPattern", "ForEachAsync" }).ToList();
             var onlyInQbs = qry.Select(m => m.Name).Except(enu.Select(m => m.Name)).Except(new[] { "ToQueryable", "get_Provider", "Empty", "Range" }).ToList();
 
-            Assert.IsTrue(onlyInObs.Count == 0, "Missing Queryable operator: " + string.Join(", ", onlyInObs.ToArray()));
-            Assert.IsTrue(onlyInQbs.Count == 0, "Missing Enumerable operator: " + string.Join(", ", onlyInQbs.ToArray()));
+            Assert.True(onlyInObs.Count == 0, "Missing Queryable operator: " + string.Join(", ", onlyInObs.ToArray()));
+            Assert.True(onlyInQbs.Count == 0, "Missing Enumerable operator: " + string.Join(", ", onlyInQbs.ToArray()));
 
             var enus = enu.GroupBy(m => m.Name);
             var qrys = qry.GroupBy(m => m.Name);
@@ -36,7 +36,7 @@ namespace Tests
 
             Func<Type, bool> filterReturn = t =>
             {
-                if (t.IsGenericType)
+                if (t.GetTypeInfo().IsGenericType)
                 {
                     var gd = t.GetGenericTypeDefinition();
                     if (gd == typeof(IBuffer<>))
@@ -63,7 +63,7 @@ namespace Tests
                     .OrderBy(x => x).ToList();
 
                 if (!group.Name.Equals("Create"))
-                    Assert.IsTrue(oss.SequenceEqual(qss), "Mismatch between QueryableEx and EnumerableEx for " + group.Name);
+                    Assert.True(oss.SequenceEqual(qss), "Mismatch between QueryableEx and EnumerableEx for " + group.Name);
             }
         }
 
@@ -76,8 +76,8 @@ namespace Tests
 
             var gens = m.IsGenericMethod ? string.Format("<{0}>", string.Join(", ", m.GetGenericArguments().Select(a => GetTypeName(a, correct)).ToArray())) : "";
 
-            var pars = string.Join(", ", pss.Select(p => (Attribute.IsDefined(p, typeof(ParamArrayAttribute)) ? "params " : "") + GetTypeName(p.ParameterType, correct) + " " + p.Name).ToArray());
-            if (Attribute.IsDefined(m, typeof(ExtensionAttribute)))
+            var pars = string.Join(", ", pss.Select(p => (p.IsDefined(typeof(ParamArrayAttribute)) ? "params " : "") + GetTypeName(p.ParameterType, correct) + " " + p.Name).ToArray());
+            if (m.IsDefined(typeof(ExtensionAttribute)))
             {
                 if (pars.StartsWith("IQbservable") || pars.StartsWith("IQueryable"))
                     pars = "this " + pars;
@@ -88,13 +88,13 @@ namespace Tests
 
         public static string GetTypeName(Type t, bool correct)
         {
-            if (t.IsGenericType)
+            if (t.GetTypeInfo().IsGenericType)
             {
                 var gtd = t.GetGenericTypeDefinition();
                 if (gtd == typeof(Expression<>))
-                    return GetTypeName(t.GetGenericArguments()[0], false);
+                    return GetTypeName(t.GenericTypeArguments[0], false);
 
-                var args = string.Join(", ", t.GetGenericArguments().Select(a => GetTypeName(a, false)).ToArray());
+                var args = string.Join(", ", t.GenericTypeArguments.Select(a => GetTypeName(a, false)).ToArray());
 
                 var len = t.Name.IndexOf('`');
                 var name = len >= 0 ? t.Name.Substring(0, len) : t.Name;
@@ -114,32 +114,32 @@ namespace Tests
             return t.Name;
         }
 
-        [TestMethod]
+        [Fact]
         public void QueryableRetarget1()
         {
             var res = QueryableEx.Provider.Empty<int>().AsEnumerable().ToList();
-            Assert.IsTrue(res.SequenceEqual(new int[0]));
+            Assert.True(res.SequenceEqual(new int[0]));
         }
 
-        [TestMethod]
+        [Fact]
         public void QueryableRetarget2()
         {
             var res = QueryableEx.Provider.Return(42).AsEnumerable().ToList();
-            Assert.IsTrue(res.SequenceEqual(new[] { 42 }));
+            Assert.True(res.SequenceEqual(new[] { 42 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void QueryableRetarget3()
         {
             var res = Enumerable.Range(0, 10).AsQueryable().TakeLast(2).AsEnumerable().ToList();
-            Assert.IsTrue(res.SequenceEqual(new[] { 8, 9 }));
+            Assert.True(res.SequenceEqual(new[] { 8, 9 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void QueryableRetarget4()
         {
             var res = QueryableEx.Provider.Range(0, 10).AsEnumerable().ToList();
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(res.SequenceEqual(Enumerable.Range(0, 10)));
         }
     }
 }

Ix.NET/Source/Tests/Tests.Single.cs

@@ -3,28 +3,28 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace Tests
 {
     public partial class Tests
     {
-        [TestMethod]
+        [Fact]
         public void Hide_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Hide<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Hide()
         {
             var xs = new List<int> { 1, 2, 3 };
             var ys = xs.Hide();
-            Assert.IsFalse(ys is List<int>);
-            Assert.IsTrue(xs.SequenceEqual(ys));
+            Assert.False(ys is List<int>);
+            Assert.True(xs.SequenceEqual(ys));
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEach_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.ForEach<int>(null, x => { }));
@@ -33,23 +33,23 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.ForEach<int>(new[] { 1 }, default(Action<int, int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEach1()
         {
             var n = 0;
             Enumerable.Range(5, 3).ForEach(x => n += x);
-            Assert.AreEqual(5 + 6 + 7, n);
+            Assert.Equal(5 + 6 + 7, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEach2()
         {
             var n = 0;
             Enumerable.Range(5, 3).ForEach((x, i) => n += x * i);
-            Assert.AreEqual(5 * 0 + 6 * 1 + 7 * 2, n);
+            Assert.Equal(5 * 0 + 6 * 1 + 7 * 2, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Buffer_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Buffer<int>(null, 5));
@@ -59,70 +59,70 @@ namespace Tests
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.Buffer<int>(new[] { 1 }, 0, 3));
         }
 
-        [TestMethod]
+        [Fact]
         public void Buffer1()
         {
             var rng = Enumerable.Range(0, 10);
 
             var res = rng.Buffer(3).ToList();
-            Assert.AreEqual(4, res.Count);
+            Assert.Equal(4, res.Count);
 
-            Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 }));
-            Assert.IsTrue(res[1].SequenceEqual(new[] { 3, 4, 5 }));
-            Assert.IsTrue(res[2].SequenceEqual(new[] { 6, 7, 8 }));
-            Assert.IsTrue(res[3].SequenceEqual(new[] { 9 }));
+            Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2 }));
+            Assert.True(res[1].SequenceEqual(new[] { 3, 4, 5 }));
+            Assert.True(res[2].SequenceEqual(new[] { 6, 7, 8 }));
+            Assert.True(res[3].SequenceEqual(new[] { 9 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Buffer2()
         {
             var rng = Enumerable.Range(0, 10);
 
             var res = rng.Buffer(5).ToList();
-            Assert.AreEqual(2, res.Count);
+            Assert.Equal(2, res.Count);
 
-            Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2, 3, 4 }));
-            Assert.IsTrue(res[1].SequenceEqual(new[] { 5, 6, 7, 8, 9 }));
+            Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2, 3, 4 }));
+            Assert.True(res[1].SequenceEqual(new[] { 5, 6, 7, 8, 9 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Buffer3()
         {
             var rng = Enumerable.Empty<int>();
 
             var res = rng.Buffer(5).ToList();
-            Assert.AreEqual(0, res.Count);
+            Assert.Equal(0, res.Count);
         }
 
-        [TestMethod]
+        [Fact]
         public void Buffer4()
         {
             var rng = Enumerable.Range(0, 10);
 
             var res = rng.Buffer(3, 2).ToList();
-            Assert.AreEqual(5, res.Count);
+            Assert.Equal(5, res.Count);
 
-            Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 }));
-            Assert.IsTrue(res[1].SequenceEqual(new[] { 2, 3, 4 }));
-            Assert.IsTrue(res[2].SequenceEqual(new[] { 4, 5, 6 }));
-            Assert.IsTrue(res[3].SequenceEqual(new[] { 6, 7, 8 }));
-            Assert.IsTrue(res[4].SequenceEqual(new[] { 8, 9 }));
+            Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2 }));
+            Assert.True(res[1].SequenceEqual(new[] { 2, 3, 4 }));
+            Assert.True(res[2].SequenceEqual(new[] { 4, 5, 6 }));
+            Assert.True(res[3].SequenceEqual(new[] { 6, 7, 8 }));
+            Assert.True(res[4].SequenceEqual(new[] { 8, 9 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Buffer5()
         {
             var rng = Enumerable.Range(0, 10);
 
             var res = rng.Buffer(3, 4).ToList();
-            Assert.AreEqual(3, res.Count);
+            Assert.Equal(3, res.Count);
 
-            Assert.IsTrue(res[0].SequenceEqual(new[] { 0, 1, 2 }));
-            Assert.IsTrue(res[1].SequenceEqual(new[] { 4, 5, 6 }));
-            Assert.IsTrue(res[2].SequenceEqual(new[] { 8, 9 }));
+            Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2 }));
+            Assert.True(res[1].SequenceEqual(new[] { 4, 5, 6 }));
+            Assert.True(res[2].SequenceEqual(new[] { 8, 9 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Do_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Do<int>(null, _ => { }));
@@ -143,42 +143,42 @@ namespace Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void Do1()
         {
             var n = 0;
             Enumerable.Range(0, 10).Do(x => n += x).ForEach(_ => { });
-            Assert.AreEqual(45, n);
+            Assert.Equal(45, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Do2()
         {
             var n = 0;
             Enumerable.Range(0, 10).Do(x => n += x, () => n *= 2).ForEach(_ => { });
-            Assert.AreEqual(90, n);
+            Assert.Equal(90, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Do3()
         {
             var ex = new MyException();
             var ok = false;
             AssertThrows<MyException>(() =>
-                EnumerableEx.Throw<int>(ex).Do(x => { Assert.Fail(); }, e => { Assert.AreEqual(ex, e); ok = true; }).ForEach(_ => { })
+                EnumerableEx.Throw<int>(ex).Do(x => { Assert.True(false); }, e => { Assert.Equal(ex, e); ok = true; }).ForEach(_ => { })
             );
-            Assert.IsTrue(ok);
+            Assert.True(ok);
         }
 
 #if !NO_RXINTERFACES
-        [TestMethod]
+        [Fact]
         public void Do4()
         {
             var obs = new MyObserver();
             Enumerable.Range(0, 10).Do(obs).ForEach(_ => { });
 
-            Assert.IsTrue(obs.Done);
-            Assert.AreEqual(45, obs.Sum);
+            Assert.True(obs.Done);
+            Assert.Equal(45, obs.Sum);
         }
 
         class MyObserver : IObserver<int>
@@ -203,55 +203,55 @@ namespace Tests
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void Do5()
         {
             var sum = 0;
             var done = false;
             Enumerable.Range(0, 10).Do(x => sum += x, ex => { throw ex; }, () => done = true).ForEach(_ => { });
 
-            Assert.IsTrue(done);
-            Assert.AreEqual(45, sum);
+            Assert.True(done);
+            Assert.Equal(45, sum);
         }
 
-        [TestMethod]
+        [Fact]
         public void StartWith_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.StartWith<int>(null, 5));
         }
 
-        [TestMethod]
+        [Fact]
         public void StartWith1()
         {
             var e = Enumerable.Range(1, 5);
             var r = e.StartWith(0).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, Enumerable.Range(0, 6)));
+            Assert.True(Enumerable.SequenceEqual(r, Enumerable.Range(0, 6)));
         }
 
-        [TestMethod]
+        [Fact]
         public void StartWith2()
         {
             var oops = false;
             var e = Enumerable.Range(1, 5).Do(_ => oops = true);
             var r = e.StartWith(0).Take(1).ToList();
-            Assert.IsFalse(oops);
+            Assert.False(oops);
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Expand<int>(null, _ => new[] { _ }));
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Expand<int>(new[] { 1 }, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand1()
         {
             var res = new[] { 0 }.Expand(x => new[] { x + 1 }).Take(10).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, Enumerable.Range(0, 10)));
+            Assert.True(Enumerable.SequenceEqual(res, Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand2()
         {
             var res = new[] { 3 }.Expand(x => Enumerable.Range(0, x)).ToList();
@@ -262,10 +262,10 @@ namespace Tests
                 0, 1,
                 0
             };
-            Assert.IsTrue(Enumerable.SequenceEqual(res, exp));
+            Assert.True(Enumerable.SequenceEqual(res, exp));
         }
 
-        [TestMethod]
+        [Fact]
         public void Distinct_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Distinct<int, int>(null, _ => _));
@@ -275,18 +275,18 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Distinct<int, int>(new[] { 1 }, _ => _, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Distinct1()
         {
             var res = Enumerable.Range(0, 10).Distinct(x => x % 5).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, Enumerable.Range(0, 5)));
+            Assert.True(Enumerable.SequenceEqual(res, Enumerable.Range(0, 5)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Distinct2()
         {
             var res = Enumerable.Range(0, 10).Distinct(x => x % 5, new MyEqualityComparer()).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 0, 1 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 0, 1 }));
         }
 
         class MyEqualityComparer : IEqualityComparer<int>
@@ -302,7 +302,7 @@ namespace Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void DistinctUntilChanged_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.DistinctUntilChanged<int>(null));
@@ -315,105 +315,105 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.DistinctUntilChanged<int, int>(new[] { 1 }, _ => _, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void DistinctUntilChanged1()
         {
             var res = new[] { 1, 2, 2, 3, 3, 3, 2, 2, 1 }.DistinctUntilChanged().ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 2, 1 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 2, 1 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void DistinctUntilChanged2()
         {
             var res = new[] { 1, 1, 2, 3, 4, 5, 5, 6, 7 }.DistinctUntilChanged(x => x / 2).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 2, 4, 6 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 4, 6 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void IgnoreElements_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.IgnoreElements<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void IgnoreElements()
         {
             var n = 0;
             Enumerable.Range(0, 10).Do(_ => n++).IgnoreElements().Take(5).ForEach(_ => { });
-            Assert.AreEqual(10, n);
+            Assert.Equal(10, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void TakeLast_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.TakeLast<int>(null, 5));
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.TakeLast<int>(new[] { 1 }, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void TakeLast_TakeZero()
         {
             var e = Enumerable.Range(1, 5) ;
             var r = e.TakeLast(0).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, Enumerable.Empty<int>()));
+            Assert.True(Enumerable.SequenceEqual(r, Enumerable.Empty<int>()));
         }
 
-        [TestMethod]
+        [Fact]
         public void TakeLast_Empty()
         {
             var e = Enumerable.Empty<int>();
             var r = e.TakeLast(1).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, e));
+            Assert.True(Enumerable.SequenceEqual(r, e));
         }
 
-        [TestMethod]
+        [Fact]
         public void TakeLast_All()
         {
             var e = Enumerable.Range(0, 5);
             var r = e.TakeLast(5).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, e));
+            Assert.True(Enumerable.SequenceEqual(r, e));
         }
 
-        [TestMethod]
+        [Fact]
         public void TakeLast_Part()
         {
             var e = Enumerable.Range(0, 5);
             var r = e.TakeLast(3).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, e.Skip(2)));
+            Assert.True(Enumerable.SequenceEqual(r, e.Skip(2)));
         }
 
-        [TestMethod]
+        [Fact]
         public void SkipLast_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.SkipLast<int>(null, 5));
             AssertThrows<ArgumentOutOfRangeException>(() => EnumerableEx.SkipLast<int>(new[] { 1 }, -1));
         }
 
-        [TestMethod]
+        [Fact]
         public void SkipLast_Empty()
         {
             var e = Enumerable.Empty<int>();
             var r = e.SkipLast(1).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, e));
+            Assert.True(Enumerable.SequenceEqual(r, e));
         }
 
-        [TestMethod]
+        [Fact]
         public void SkipLast_All()
         {
             var e = Enumerable.Range(0, 5);
             var r = e.SkipLast(0).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, e));
+            Assert.True(Enumerable.SequenceEqual(r, e));
         }
 
-        [TestMethod]
+        [Fact]
         public void SkipLast_Part()
         {
             var e = Enumerable.Range(0, 5);
             var r = e.SkipLast(3).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(r, e.Take(2)));
+            Assert.True(Enumerable.SequenceEqual(r, e.Take(2)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scan_Arguments()
         {
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Scan<int>(null, (x, y) => x + y));
@@ -422,18 +422,18 @@ namespace Tests
             AssertThrows<ArgumentNullException>(() => EnumerableEx.Scan<int, int>(new[] { 1 }, 0, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scan1()
         {
             var res = Enumerable.Range(0, 5).Scan((n, x) => n + x).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 1, 3, 6, 10 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 3, 6, 10 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scan2()
         {
             var res = Enumerable.Range(0, 5).Scan(10, (n, x) => n - x).ToList();
-            Assert.IsTrue(Enumerable.SequenceEqual(res, new[] { 10, 9, 7, 4, 0 }));
+            Assert.True(Enumerable.SequenceEqual(res, new[] { 10, 9, 7, 4, 0 }));
         }
     }
 }

Ix.NET/Source/Tests/Tests.cs

@@ -3,24 +3,18 @@ using System;
 using System.Text;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
+
 
 namespace Tests
 {
-    [TestClass]
+    
     public partial class Tests
     {
         public void AssertThrows<E>(Action a)
             where E : Exception
         {
-            try
-            {
-                a();
-                Assert.Fail();
-            }
-            catch (E)
-            {
-            }
+            Assert.Throws<E>(a);
         }
 
         public void AssertThrows<E>(Action a, Func<E, bool> assert)
@@ -29,23 +23,23 @@ namespace Tests
             try
             {
                 a();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (E e)
             {
-                Assert.IsTrue(assert(e));
+                Assert.True(assert(e));
             }
         }
 
         public void NoNext<T>(IEnumerator<T> e)
         {
-            Assert.IsFalse(e.MoveNext());
+            Assert.False(e.MoveNext());
         }
 
         public void HasNext<T>(IEnumerator<T> e, T value)
         {
-            Assert.IsTrue(e.MoveNext());
-            Assert.AreEqual(value, e.Current);
+            Assert.True(e.MoveNext());
+            Assert.Equal(value, e.Current);
         }
     }
 }

Ix.NET/Source/Tests/project.json

@@ -11,20 +11,13 @@
     "requireLicenseAcceptance": true,
     "dependencies": {
         "System.Interactive.Providers": { "target": "project" },
-        "System.Interactive.Async.Providers": { "target": "project" }
+        "System.Interactive.Async.Providers": { "target": "project" },
+        "xunit": "2.1.0"
     },
+    "exclude": [
+        "App.cs"
+    ],
     "frameworks": {
-        "net40": {
-            "compilationOptions": {
-                "define": [
-                    "NO_TASK_DELAY",
-                    "HAS_APTCA",
-                    "HAS_WINFORMS",
-                    "USE_TIMER_SELF_ROOT",
-                    "NO_WEAKREFOFT"
-                ]
-            }
-        },
         "net45": {
             "compilationOptions": {
                 "define": [
@@ -39,6 +32,10 @@
                     "HAS_WINFORMS",
                     "USE_TIMER_SELF_ROOT"
                 ]
+            },
+            "frameworkAssemblies": {
+                "System.Runtime": "4.0.0.0",
+                "System.Threading.Tasks": "4.0.0.0"
             }
         },
         "dotnet5.1": {