Merge pull request #13 from shiftkey/test-port-core-port

Test port core port

Rx.NET/Source/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.xproj

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>a0fa7fb5-bc2b-4e9f-9807-40bc26894ad5</ProjectGuid>
+    <RootNamespace>Microsoft.Reactive.Testing</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">..\..\..\artifacts\obj\$(MSBuildProjectName)</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">..\..\..\artifacts\bin\$(MSBuildProjectName)\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+    <TypeScriptCompileBlocked>True</TypeScriptCompileBlocked>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
+  <ProjectExtensions>
+    <VisualStudio>
+      <UserProperties project_1json__JSONSchema="http://json.schemastore.org/project-1.0.0-beta8" />
+    </VisualStudio>
+  </ProjectExtensions>
+</Project>

Rx.NET/Source/Microsoft.Reactive.Testing/ReactiveAssert.cs

@@ -7,12 +7,7 @@ using System.Linq;
 using System.Text;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
-
-#if WINDOWS8 || WINDOWS81
-using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
-#else
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-#endif
+using Xunit;
 
 namespace Microsoft.Reactive.Testing
 {
@@ -51,7 +46,7 @@ namespace Microsoft.Reactive.Testing
                 throw new ArgumentNullException("actual");
 
             if (!expected.SequenceEqual(actual))
-                Assert.Fail(Message(actual, expected));
+                Assert.True(false, Message(actual, expected));
         }
 
         /// <summary>
@@ -70,7 +65,7 @@ namespace Microsoft.Reactive.Testing
                 throw new ArgumentNullException("actual");
 
             if (!expected.SequenceEqual(actual))
-                Assert.Fail(message);
+                Assert.True(false, message);
         }
 
         /// <summary>
@@ -130,11 +125,11 @@ namespace Microsoft.Reactive.Testing
             }
             catch (Exception ex)
             {
-                Assert.Fail(string.Format(CultureInfo.CurrentCulture, "Expected {0} threw {1}.\r\n\r\nStack trace:\r\n{2}", typeof(TException).Name, ex.GetType().Name, ex.StackTrace));
+                Assert.True(false, string.Format(CultureInfo.CurrentCulture, "Expected {0} threw {1}.\r\n\r\nStack trace:\r\n{2}", typeof(TException).Name, ex.GetType().Name, ex.StackTrace));
             }
 
             if (failed)
-                Assert.Fail(string.Format(CultureInfo.CurrentCulture, "Expected {0}.", typeof(TException).Name));
+                Assert.True(false, string.Format(CultureInfo.CurrentCulture, "Expected {0}.", typeof(TException).Name));
         }
 
         /// <summary>
@@ -160,11 +155,11 @@ namespace Microsoft.Reactive.Testing
             }
             catch
             {
-                Assert.Fail(message);
+                Assert.True(false, message);
             }
 
             if (failed)
-                Assert.Fail(message);
+                Assert.True(false, message);
         }
 
         /// <summary>
@@ -187,15 +182,15 @@ namespace Microsoft.Reactive.Testing
             }
             catch (TException ex)
             {
-                Assert.AreSame(exception, ex);
+                Assert.Same(exception, ex);
             }
             catch (Exception ex)
             {
-                Assert.Fail(string.Format(CultureInfo.CurrentCulture, "Expected {0} threw {1}.\r\n\r\nStack trace:\r\n{2}", typeof(TException).Name, ex.GetType().Name, ex.StackTrace));
+                Assert.True(false, string.Format(CultureInfo.CurrentCulture, "Expected {0} threw {1}.\r\n\r\nStack trace:\r\n{2}", typeof(TException).Name, ex.GetType().Name, ex.StackTrace));
             }
 
             if (failed)
-                Assert.Fail(string.Format(CultureInfo.CurrentCulture, "Expected {0}.", typeof(TException).Name));
+                Assert.True(false, string.Format(CultureInfo.CurrentCulture, "Expected {0}.", typeof(TException).Name));
         }
 
         /// <summary>
@@ -219,15 +214,15 @@ namespace Microsoft.Reactive.Testing
             }
             catch (TException ex)
             {
-                Assert.AreSame(exception, ex);
+                Assert.Same(exception, ex);
             }
             catch
             {
-                Assert.Fail(message);
+                Assert.True(false, message);
             }
 
             if (failed)
-                Assert.Fail(message);
+                Assert.True(false, message);
         }
 
         /// <summary>

Rx.NET/Source/Microsoft.Reactive.Testing/project.json

@@ -0,0 +1,97 @@
+{
+  "version": "3.0.0-*",
+  "title": "Microsoft.Reactive.Testing - Testing Helper Library",
+  "description": "Reactive Extensions Testing Library containing interfaces and classes providing functionality to test applications and libraries built using Reactive Extensions.",
+  "authors": [ "Microsoft" ],
+  "copyright": "Copyright (C) Microsoft Corporation",
+  "tags": [ "Rx", "Reactive", "Extensions", "Observable", "LINQ", "Events" ],
+  "iconUrl": "http://go.microsoft.com/fwlink/?LinkId=261274",
+  "projectUrl": "http://go.microsoft.com/fwlink/?LinkId=261273",
+  "licenseUrl": "http://go.microsoft.com/fwlink/?LinkID=261272",
+  "requireLicenseAcceptance": true,
+
+  "dependencies": {
+    "System.Reactive.Linq": { "target": "project" },
+    "System.Reactive.PlatformServices": { "target": "project" },
+    "xunit": "2.1.0"
+  },
+
+  "frameworks": {
+    "net45": {
+      "compilationOptions": {
+        "define": [
+          "NO_EVENTARGS_CONSTRAINT",
+          "HAS_EDI",
+          "HAS_WINRT",
+          "HAS_PROGRESS",
+          "PREFER_ASYNC",
+          "HAS_AWAIT",
+          "HAS_APTCA",
+          "HAS_DISPATCHER_PRIORITY",
+          "HAS_WINFORMS",
+          "USE_TIMER_SELF_ROOT"
+        ]
+      },
+      "frameworkAssemblies": {
+        "System.Runtime": "4.0.0.0"
+      }
+    },
+    "dotnet5.1": {
+      "compilationOptions": {
+        "define": [
+          "NO_EVENTARGS_CONSTRAINT",
+          "HAS_EDI",
+          "HAS_WINRT",
+          "HAS_PROGRESS",
+          "PREFER_ASYNC",
+          "HAS_AWAIT",
+          "HAS_APTCA",
+          "NO_REMOTING",
+          "NO_SERIALIZABLE",
+          "NO_THREAD",
+          "NO_WEAKTABLE",
+          "CRIPPLED_REFLECTION",
+          "PLIB",
+          "USE_TIMER_SELF_ROOT"
+        ]
+      },
+      "dependencies": {
+        "System.Linq": "4.0.0",
+        "System.Collections.Concurrent": "4.0.0",
+        "System.ComponentModel": "4.0.0",
+        "System.Threading": "4.0.0",
+        "System.Threading.Timer": "4.0.0",
+        "System.Runtime": "4.0.0",
+        "System.Runtime.Extensions": "4.0.0"
+      }
+
+    },
+    "dotnet5.4": {
+      "compilationOptions": {
+        "define": [
+          "NO_EVENTARGS_CONSTRAINT",
+          "HAS_EDI",
+          "HAS_WINRT",
+          "HAS_PROGRESS",
+          "PREFER_ASYNC",
+          "HAS_AWAIT",
+          "HAS_APTCA",
+          "NO_REMOTING",
+          "NO_SERIALIZABLE",
+          "NO_THREAD",
+          "CRIPPLED_REFLECTION",
+          "PLIB",
+          "USE_TIMER_SELF_ROOT"
+        ]
+      },
+      "dependencies": {
+        "System.Diagnostics.Tools": "4.0.1-beta-23516",
+        "System.Linq": "4.0.1-beta-23516",
+        "System.Linq.Expressions": "4.0.11-beta-23516",
+        "System.Resources.ResourceManager": "4.0.1-beta-23516",
+        "System.Threading": "4.0.11-beta-23516",
+        "System.Runtime": "4.0.21-beta-23516"
+      }
+    }
+  }
+}

Rx.NET/Source/Rx-New.sln

@@ -28,6 +28,12 @@ Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "System.Reactive.Windows.For
 EndProject
 Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "System.Reactive.WindowsRuntime", "System.Reactive.WindowsRuntime\System.Reactive.WindowsRuntime.xproj", "{4B697BE9-1D48-4855-9070-C9C5C3BD341C}"
 EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.Reactive.Testing", "Microsoft.Reactive.Testing\Microsoft.Reactive.Testing.xproj", "{A0FA7FB5-BC2B-4E9F-9807-40BC26894AD5}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{8DB69669-2C09-404B-B29A-79641919078B}"
+EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Tests.System.Reactive", "Tests.System.Reactive\Tests.System.Reactive.xproj", "{78C7DAD3-D706-4D0A-A4F9-5C7EA1CB9D6D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -78,6 +84,14 @@ Global
 		{4B697BE9-1D48-4855-9070-C9C5C3BD341C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4B697BE9-1D48-4855-9070-C9C5C3BD341C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4B697BE9-1D48-4855-9070-C9C5C3BD341C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A0FA7FB5-BC2B-4E9F-9807-40BC26894AD5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A0FA7FB5-BC2B-4E9F-9807-40BC26894AD5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A0FA7FB5-BC2B-4E9F-9807-40BC26894AD5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A0FA7FB5-BC2B-4E9F-9807-40BC26894AD5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{78C7DAD3-D706-4D0A-A4F9-5C7EA1CB9D6D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{78C7DAD3-D706-4D0A-A4F9-5C7EA1CB9D6D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{78C7DAD3-D706-4D0A-A4F9-5C7EA1CB9D6D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{78C7DAD3-D706-4D0A-A4F9-5C7EA1CB9D6D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -94,5 +108,7 @@ Global
 		{A22F3131-6D20-4D67-9A9F-314FE3691EA1} = {16A2D2FA-6D59-498E-8160-66518531792E}
 		{C17D3BD1-222F-4DCC-BBF8-44A04399701B} = {0410EFCB-757C-46BA-99AA-A82A06A79F64}
 		{4B697BE9-1D48-4855-9070-C9C5C3BD341C} = {0410EFCB-757C-46BA-99AA-A82A06A79F64}
+		{A0FA7FB5-BC2B-4E9F-9807-40BC26894AD5} = {0410EFCB-757C-46BA-99AA-A82A06A79F64}
+		{78C7DAD3-D706-4D0A-A4F9-5C7EA1CB9D6D} = {8DB69669-2C09-404B-B29A-79641919078B}
 	EndGlobalSection
 EndGlobal

Rx.NET/Source/System.Reactive.Experimental/project.json

@@ -44,6 +44,33 @@
                 ]
             }
         },
+        "dotnet5.1": {
+            "compilationOptions": {
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "NO_REMOTING",
+                    "NO_SERIALIZABLE",
+                    "NO_THREAD",
+                    "CRIPPLED_REFLECTION",
+                    "PLIB",
+                    "USE_TIMER_SELF_ROOT"
+                ]
+            },
+            "dependencies": {
+                "System.Diagnostics.Tools": "4.0.0",
+                "System.Linq": "4.0.0",
+                "System.Linq.Expressions": "4.0.0",
+                "System.Resources.ResourceManager": "4.0.0",
+                "System.Threading": "4.0.0",
+                "System.Runtime": "4.0.0"
+            }
+        },
         "dotnet5.4": {
             "compilationOptions": {
                 "define": [

Rx.NET/Source/System.Reactive.Observable.Aliases/project.json

@@ -14,61 +14,88 @@
     "System.Reactive.Providers": { "target": "project" }
   },
 
-  "frameworks": {
-    "net40": {
-      "compilationOptions": {
-        "define": [
-          "NO_TASK_DELAY",
-          "HAS_APTCA",
-          "HAS_WINFORMS",
-          "USE_TIMER_SELF_ROOT",
-          "NO_WEAKREFOFT"
-        ]
-      }
-    },
-    "net45": {
-      "compilationOptions": {
-        "define": [
-          "NO_EVENTARGS_CONSTRAINT",
-          "HAS_EDI",
-          "HAS_WINRT",
-          "HAS_PROGRESS",
-          "PREFER_ASYNC",
-          "HAS_AWAIT",
-          "HAS_APTCA",
-          "HAS_DISPATCHER_PRIORITY",
-          "HAS_WINFORMS",
-          "USE_TIMER_SELF_ROOT"
-        ]
-      }
-    },
-    "dotnet5.4": {
-      "compilationOptions": {
-        "define": [
-          "NO_EVENTARGS_CONSTRAINT",
-          "HAS_EDI",
-          "HAS_WINRT",
-          "HAS_PROGRESS",
-          "PREFER_ASYNC",
-          "HAS_AWAIT",
-          "HAS_APTCA",
-          "NO_REMOTING",
-          "NO_SERIALIZABLE",
-          "NO_THREAD",
-          "CRIPPLED_REFLECTION",
-          "PLIB",
-          "USE_TIMER_SELF_ROOT"
-        ]
-      },
-      "dependencies": {
-        "System.Collections.Concurrent": "4.0.11-beta-23516",
-        "System.ComponentModel": "4.0.1-beta-23516",
-        "System.Linq": "4.0.1-beta-23516",
-        "System.Threading": "4.0.11-beta-23516",
-        "System.Threading.Thread": "4.0.0-beta-23516",
-        "System.Threading.ThreadPool": "4.0.10-beta-23516",
-        "System.Threading.Timer": "4.0.1-beta-23516"
-      }
+    "frameworks": {
+        "net40": {
+            "compilationOptions": {
+                "define": [
+                    "NO_TASK_DELAY",
+                    "HAS_APTCA",
+                    "HAS_WINFORMS",
+                    "USE_TIMER_SELF_ROOT",
+                    "NO_WEAKREFOFT"
+                ]
+            }
+        },
+        "net45": {
+            "compilationOptions": {
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "HAS_DISPATCHER_PRIORITY",
+                    "HAS_WINFORMS",
+                    "USE_TIMER_SELF_ROOT"
+                ]
+            }
+        },
+        "dotnet5.1": {
+            "compilationOptions": {
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "NO_REMOTING",
+                    "NO_SERIALIZABLE",
+                    "NO_THREAD",
+                    "CRIPPLED_REFLECTION",
+                    "PLIB",
+                    "USE_TIMER_SELF_ROOT"
+                ]
+            },
+            "dependencies": {
+                "System.Diagnostics.Tools": "4.0.0",
+                "System.Linq": "4.0.0",
+                "System.Linq.Expressions": "4.0.0",
+                "System.Resources.ResourceManager": "4.0.0",
+                "System.Threading": "4.0.0",
+                "System.Runtime": "4.0.0"
+            }
+        },
+        "dotnet5.4": {
+            "compilationOptions": {
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "NO_REMOTING",
+                    "NO_SERIALIZABLE",
+                    "NO_THREAD",
+                    "CRIPPLED_REFLECTION",
+                    "PLIB",
+                    "USE_TIMER_SELF_ROOT"
+                ]
+            },
+            "dependencies": {
+                "System.Collections.Concurrent": "4.0.11-beta-23516",
+                "System.ComponentModel": "4.0.1-beta-23516",
+                "System.Linq": "4.0.1-beta-23516",
+                "System.Threading": "4.0.11-beta-23516",
+                "System.Threading.Thread": "4.0.0-beta-23516",
+                "System.Threading.ThreadPool": "4.0.10-beta-23516",
+                "System.Threading.Timer": "4.0.1-beta-23516"
+            }
+        }
     }
-  }
 }

Rx.NET/Source/System.Reactive.Providers/project.json

@@ -27,52 +27,82 @@
             }
         },
         "net45": {
-          "compilationOptions": {
-            "define": [
-              "NO_EVENTARGS_CONSTRAINT",
-              "HAS_EDI",
-              "HAS_WINRT",
-              "HAS_PROGRESS",
-              "PREFER_ASYNC",
-              "HAS_AWAIT",
-              "HAS_APTCA",
-              "HAS_DISPATCHER_PRIORITY",
-              "HAS_WINFORMS",
-              "USE_TIMER_SELF_ROOT"
-            ]
-          },
-          "dependencies": {
-            "System.Reflection": "4.1.0-beta-23516"
-          }
+            "compilationOptions": {
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "HAS_DISPATCHER_PRIORITY",
+                    "HAS_WINFORMS",
+                    "USE_TIMER_SELF_ROOT"
+                ]
+            },
+            "dependencies": {
+                "System.Reflection": "4.1.0-beta-23516"
+            }
+        },
+        "dotnet5.1": {
+            "compilationOptions": {
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "NO_REMOTING",
+                    "NO_SERIALIZABLE",
+                    "NO_THREAD",
+                    "CRIPPLED_REFLECTION",
+                    "PLIB",
+                    "USE_TIMER_SELF_ROOT"
+                ]
+            },
+            "dependencies": {
+                "System.Diagnostics.Tools": "4.0.0",
+                "System.Linq": "4.0.0",
+                "System.Linq.Queryable": "4.0.0",
+                "System.Linq.Expressions": "4.0.0",
+                "System.Resources.ResourceManager": "4.0.0",
+                "System.Reflection": "4.0.0",
+                "System.Threading": "4.0.0",
+                "System.Runtime": "4.0.0",
+                "System.Reflection.Extensions": "4.0.0"
+            }
         },
         "dotnet5.4": {
             "compilationOptions": {
-              "define": [
-                "NO_EVENTARGS_CONSTRAINT",
-                "HAS_EDI",
-                "HAS_WINRT",
-                "HAS_PROGRESS",
-                "PREFER_ASYNC",
-                "HAS_AWAIT",
-                "HAS_APTCA",
-                "NO_REMOTING",
-                "NO_SERIALIZABLE",
-                "NO_THREAD",
-                "CRIPPLED_REFLECTION",
-                "PLIB",
-                "USE_TIMER_SELF_ROOT"
-              ]
+                "define": [
+                    "NO_EVENTARGS_CONSTRAINT",
+                    "HAS_EDI",
+                    "HAS_WINRT",
+                    "HAS_PROGRESS",
+                    "PREFER_ASYNC",
+                    "HAS_AWAIT",
+                    "HAS_APTCA",
+                    "NO_REMOTING",
+                    "NO_SERIALIZABLE",
+                    "NO_THREAD",
+                    "CRIPPLED_REFLECTION",
+                    "PLIB",
+                    "USE_TIMER_SELF_ROOT"
+                ]
             },
-          "dependencies": {
-            "System.Collections.Concurrent": "4.0.11-beta-23516",
-            "System.ComponentModel": "4.0.1-beta-23516",
-            "System.Linq": "4.0.1-beta-23516",
-            "System.Linq.Queryable": "4.0.1-beta-23516",
-            "System.Threading": "4.0.11-beta-23516",
-            "System.Threading.Thread": "4.0.0-beta-23516",
-            "System.Threading.ThreadPool": "4.0.10-beta-23516",
-            "System.Threading.Timer": "4.0.1-beta-23516"
-          }
+            "dependencies": {
+                "System.Collections.Concurrent": "4.0.11-beta-23516",
+                "System.ComponentModel": "4.0.1-beta-23516",
+                "System.Linq": "4.0.1-beta-23516",
+                "System.Linq.Queryable": "4.0.1-beta-23516",
+                "System.Threading": "4.0.11-beta-23516",
+                "System.Threading.Thread": "4.0.0-beta-23516",
+                "System.Threading.ThreadPool": "4.0.10-beta-23516",
+                "System.Threading.Timer": "4.0.1-beta-23516"
+            }
         }
     }
 }

Rx.NET/Source/System.Reactive.Runtime.Remoting/project.json

@@ -40,39 +40,7 @@
               "HAS_WINFORMS",
               "USE_TIMER_SELF_ROOT"
             ]
-          },
-          "dependencies": {
-            "System.Reflection": "4.1.0-beta-23516"
-          }
-        },
-        "dotnet5.4": {
-            "compilationOptions": {
-              "define": [
-                "NO_EVENTARGS_CONSTRAINT",
-                "HAS_EDI",
-                "HAS_WINRT",
-                "HAS_PROGRESS",
-                "PREFER_ASYNC",
-                "HAS_AWAIT",
-                "HAS_APTCA",
-                "NO_REMOTING",
-                "NO_SERIALIZABLE",
-                "NO_THREAD",
-                "CRIPPLED_REFLECTION",
-                "PLIB",
-                "USE_TIMER_SELF_ROOT"
-              ]
-            },
-          "dependencies": {
-            "System.Collections.Concurrent": "4.0.11-beta-23516",
-            "System.ComponentModel": "4.0.1-beta-23516",
-            "System.Linq": "4.0.1-beta-23516",
-            "System.Linq.Queryable": "4.0.1-beta-23516",
-            "System.Threading": "4.0.11-beta-23516",
-            "System.Threading.Thread": "4.0.0-beta-23516",
-            "System.Threading.ThreadPool": "4.0.10-beta-23516",
-            "System.Threading.Timer": "4.0.1-beta-23516"
-          }
+          }    
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/DispatcherHelpers.cs

@@ -1,11 +1,15 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
 using System;
+#if DOTNET5_1
 using System.Threading;
+#else
 using System.Windows.Threading;
+#endif
 
 namespace ReactiveTests
 {
+#if HAS_DISPATCHER
     static class DispatcherHelpers
     {
         public static DispatcherWrapper EnsureDispatcher()
@@ -24,7 +28,7 @@ namespace ReactiveTests
 
             return new DispatcherWrapper(d);
 #else
-            return new DispatcherWrapper(System.Windows.Deployment.Current.Dispatcher);
+            return new DispatcherWrapper(Dispatcher.CurrentDispatcher);
 #endif
         }
     }
@@ -65,4 +69,5 @@ namespace ReactiveTests
             _dispatcher.BeginInvoke(action);
         }
     }
+#endif
 }

Rx.NET/Source/Tests.System.Reactive/Stress/Core/Schedulers/EventLoop.cs

@@ -9,7 +9,7 @@ using System.Reactive.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Stress.Schedulers
 {
@@ -26,7 +26,7 @@ namespace ReactiveTests.Stress.Schedulers
 
             using (var scheduler = new EventLoopScheduler())
             {
-                Assert.AreEqual(0, scheduler.CurrentCount());
+                Assert.Equal(0, scheduler.CurrentCount());
 
                 var maxCount = Environment.ProcessorCount;
 

Rx.NET/Source/Tests.System.Reactive/Stress/Linq/Delay.cs

@@ -1,9 +1,11 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
-
+#define DEBUG // For debug.writeline
 using System;
+using System.Diagnostics;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 
+
 namespace ReactiveTests.Stress.Linq
 {
     public class Delay
@@ -17,7 +19,7 @@ namespace ReactiveTests.Stress.Linq
             {
                 foreach (var N in new[] { 1, 10, 100, 1000, 10000, 100000 })
                 {
-                    Console.WriteLine("N = {0}", N);
+                    Debug.WriteLine("N = {0}", N);
                     foreach (var d in new[] { 1, 10, 20, 50, 100, 200, 250, 500 })
                     {
                         try
@@ -27,13 +29,13 @@ namespace ReactiveTests.Stress.Linq
                         }
                         catch (Exception)
                         {
-                            Console.Write(".");
+                            Debug.Write(".");
                             continue;
                         }
 
                         throw new InvalidOperationException("Didn't throw!");
                     }
-                    Console.WriteLine();
+                    Debug.WriteLine("");
                 }
             }
         }
@@ -47,16 +49,16 @@ namespace ReactiveTests.Stress.Linq
             {
                 foreach (var N in new[] { 1, 10, 100, 1000, 10000, 100000 })
                 {
-                    Console.WriteLine("N = {0}", N);
+                    Debug.WriteLine("N = {0}", N);
                     foreach (var d in new[] { 1, 10, 20, 50, 100, 200, 250, 500 })
                     {
                         var n = Observable.Range(0, N, NewThreadScheduler.Default).Delay(TimeSpan.FromMilliseconds(d), NewThreadScheduler.Default).Count().Wait();
                         if (n != N)
                             throw new InvalidOperationException("Lost OnNext message!");
 
-                        Console.Write(".");
+                        Debug.Write(".");
                     }
-                    Console.WriteLine();
+                    Debug.WriteLine("");
                 }
             }
         }

Rx.NET/Source/Tests.System.Reactive/TestLongRunningScheduler.cs

@@ -4,6 +4,7 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace ReactiveTests
 {
@@ -55,7 +56,7 @@ namespace ReactiveTests
             var ee = new ManualResetEvent(false);
             _setEnd(ee);
 
-            new Thread(() =>
+            Task.Run(() =>
             {
                 eb.Set();
                 try
@@ -73,7 +74,7 @@ namespace ReactiveTests
                 {
                     ee.Set();
                 }
-            }).Start();
+            });
 
             return d;
         }

Rx.NET/Source/Tests.System.Reactive/Tests.System.Reactive.xproj

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>78c7dad3-d706-4d0a-a4f9-5c7ea1cb9d6d</ProjectGuid>
+    <RootNamespace>System.Reactive</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">..\..\..\artifacts\obj\$(MSBuildProjectName)</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">..\..\..\artifacts\bin\$(MSBuildProjectName)\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
+  <ProjectExtensions>
+    <VisualStudio>
+      <UserProperties project_1json__JSONSchema="http://json.schemastore.org/project-1.0.0-beta8" />
+    </VisualStudio>
+  </ProjectExtensions>
+</Project>

Rx.NET/Source/Tests.System.Reactive/Tests/Aliases.cs

@@ -7,24 +7,24 @@ using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Reactive.Linq;
 using System.Reactive.Observable.Aliases;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class AliasesTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Qbservable_Aliases()
         {
             var xs = Observable.Return(1).AsQbservable();
 
-            Assert.IsTrue(xs.Filter(x => true).ToEnumerable().SequenceEqual(new[] { 1 }), "Filter");
-            Assert.IsTrue(xs.Filter(x => true).Concat(xs.Filter(x => false)).ToEnumerable().SequenceEqual(new[] { 1 }), "Concat/Filter");
-            Assert.IsTrue(xs.Map(x => x.ToString()).ToEnumerable().SequenceEqual(new[] { "1" }), "Map");
-            Assert.IsTrue(xs.FlatMap(x => xs).ToEnumerable().SequenceEqual(new[] { 1 }), "FlatMap");
+            Assert.True(xs.Filter(x => true).ToEnumerable().SequenceEqual(new[] { 1 }), "Filter");
+            Assert.True(xs.Filter(x => true).Concat(xs.Filter(x => false)).ToEnumerable().SequenceEqual(new[] { 1 }), "Concat/Filter");
+            Assert.True(xs.Map(x => x.ToString()).ToEnumerable().SequenceEqual(new[] { "1" }), "Map");
+            Assert.True(xs.FlatMap(x => xs).ToEnumerable().SequenceEqual(new[] { 1 }), "FlatMap");
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/AnonymousTest.cs

@@ -1,22 +1,22 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
 using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using Microsoft.Reactive.Testing;
 using System.Reactive;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class AnonymousTest
     {
-        [TestMethod]
+        [Fact]
         public void AnonymousObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new AnonymousObservable<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void AnonymousObserver_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new AnonymousObserver<int>(default(Action<int>)));
@@ -32,7 +32,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new AnonymousObserver<int>(x => { }, ex => { }, default(Action)));
         }
 
-        [TestMethod]
+        [Fact]
         public void AnonymousObserver_Error_Null()
         {
             var observer = new AnonymousObserver<int>(_ => { }, e => { }, () => { });

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/AsyncLockTest.cs

@@ -2,31 +2,32 @@
 
 #if !SILVERLIGHT // MethodAccessException
 using System;
+using System.Threading.Tasks;
 using System.Reactive.Concurrency;
 using System.Reflection;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class AsyncLockTest
     {
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void Wait_ArgumentChecking()
         {
             var asyncLock = new AsyncLock();
-            asyncLock.Wait(null);
+            Assert.Throws<ArgumentNullException>(() => asyncLock.Wait(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Wait_Graceful()
         {
             var ok = false;
             new AsyncLock().Wait(() => { ok = true; });
-            Assert.IsTrue(ok);
+            Assert.True(ok);
         }
 
-        [TestMethod]
+        [Fact]
         public void Wait_Fail()
         {
             var l = new AsyncLock();
@@ -35,29 +36,29 @@ namespace ReactiveTests.Tests
             try
             {
                 l.Wait(() => { throw ex; });
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
-                Assert.AreSame(ex, e);
+                Assert.Same(ex, e);
             }
 
             // has faulted; should not run
-            l.Wait(() => { Assert.Fail(); });
+            l.Wait(() => { Assert.True(false); });
         }
 
-        [TestMethod]
+        [Fact]
         public void Wait_QueuesWork()
         {
             var l = new AsyncLock();
 
             var l1 = false;
             var l2 = false;
-            l.Wait(() => { l.Wait(() => { Assert.IsTrue(l1); l2 = true; }); l1 = true; });
-            Assert.IsTrue(l2);
+            l.Wait(() => { l.Wait(() => { Assert.True(l1); l2 = true; }); l1 = true; });
+            Assert.True(l2);
         }
 
-        [TestMethod]
+        [Fact]
         public void Dispose()
         {
             var l = new AsyncLock();
@@ -89,10 +90,10 @@ namespace ReactiveTests.Tests
                 l1 = true;
             });
 
-            Assert.IsTrue(l1);
-            Assert.IsTrue(l2);
-            Assert.IsFalse(l3);
-            Assert.IsFalse(l4);
+            Assert.True(l1);
+            Assert.True(l2);
+            Assert.False(l3);
+            Assert.False(l4);
         }
 
         public class AsyncLock
@@ -101,7 +102,7 @@ namespace ReactiveTests.Tests
 
             public AsyncLock()
             {
-                instance = typeof(Scheduler).Assembly.GetType("System.Reactive.Concurrency.AsyncLock").GetConstructor(new Type[] { }).Invoke(new object[] { });
+                instance = typeof(Scheduler).GetTypeInfo().Assembly.GetType("System.Reactive.Concurrency.AsyncLock").GetConstructor(new Type[] { }).Invoke(new object[] { });
             }
 
             public void Wait(Action action)

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/ConcurrencyTest.cs

@@ -3,14 +3,14 @@
 using System;
 using System.Reactive.Concurrency;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ConcurrencyTest
     {
-        [TestMethod]
+        [Fact]
         public void CurrentScheduler_EnsureTrampoline()
         {
             const int concurrency = 100;
@@ -46,10 +46,10 @@ namespace ReactiveTests.Tests
             for (var i = 0; i < concurrency; ++i)
                 s.WaitOne();
 
-            Assert.IsTrue(passed);
+            Assert.True(passed);
         }
 
-        [TestMethod]
+        [Fact]
         public void CurrentScheduler_Schedule()
         {
             const int concurrency = 100;
@@ -85,7 +85,7 @@ namespace ReactiveTests.Tests
             for (var i = 0; i < concurrency; ++i)
                 s.WaitOne();
 
-            Assert.IsTrue(passed);
+            Assert.True(passed);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/ControlSchedulerTest.cs

@@ -8,35 +8,35 @@ using System.Reactive.Disposables;
 using System.Diagnostics;
 using System.Threading;
 using System.Windows.Forms;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using Microsoft.Reactive.Testing;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ControlSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void Ctor_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ControlScheduler(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Control()
         {
             var lbl = new Label();
-            Assert.AreSame(lbl, new ControlScheduler(lbl).Control);
+            Assert.Same(lbl, new ControlScheduler(lbl).Control);
         }
 
-        [TestMethod]
+        [Fact]
         public void Now()
         {
             var res = new ControlScheduler(new Label()).Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Schedule_ArgumentChecking()
         {
             var s = new ControlScheduler(new Label());
@@ -45,7 +45,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Schedule()
         {
             var evt = new ManualResetEvent(false);
@@ -55,14 +55,14 @@ namespace ReactiveTests.Tests
             var lbl = CreateLabel();
             var sch = new ControlScheduler(lbl);
             
-            sch.Schedule(() => { lbl.Text = "Okay"; Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); });
-            sch.Schedule(() => { Assert.AreEqual("Okay", lbl.Text); Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            sch.Schedule(() => { lbl.Text = "Okay"; Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); });
+            sch.Schedule(() => { Assert.Equal("Okay", lbl.Text); Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
 
             evt.WaitOne();
             Application.Exit();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleError()
         {
             var evt = new ManualResetEvent(false);
@@ -70,7 +70,7 @@ namespace ReactiveTests.Tests
             var ex = new Exception();
 
             var lbl = CreateLabelWithHandler(e => {
-                Assert.AreSame(ex, e);
+                Assert.Same(ex, e);
                 evt.Set();
             });
 
@@ -81,13 +81,13 @@ namespace ReactiveTests.Tests
             Application.Exit();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative()
         {
             ScheduleRelative_(TimeSpan.FromSeconds(0.1));
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative_Zero()
         {
             ScheduleRelative_(TimeSpan.Zero);
@@ -105,12 +105,12 @@ namespace ReactiveTests.Tests
             sch.Schedule(delay, () =>
             {
                 lbl.Text = "Okay";
-                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                 
                 sch.Schedule(() =>
                 {
-                    Assert.AreEqual("Okay", lbl.Text);
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.Equal("Okay", lbl.Text);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                     evt.Set();
                 });
             });
@@ -119,7 +119,7 @@ namespace ReactiveTests.Tests
             Application.Exit();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative_Nested()
         {
             var evt = new ManualResetEvent(false);
@@ -134,12 +134,12 @@ namespace ReactiveTests.Tests
                 sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
                 {
                     lbl.Text = "Okay";
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                     sch.Schedule(() =>
                     {
-                        Assert.AreEqual("Okay", lbl.Text);
-                        Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                        Assert.Equal("Okay", lbl.Text);
+                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                         evt.Set();
                     });
                 });
@@ -149,7 +149,7 @@ namespace ReactiveTests.Tests
             Application.Exit();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative_Cancel()
         {
             var evt = new ManualResetEvent(false);
@@ -162,7 +162,7 @@ namespace ReactiveTests.Tests
             sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
             {
                 lbl.Text = "Okay";
-                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                 var d = sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
                 {
@@ -176,8 +176,8 @@ namespace ReactiveTests.Tests
 
                 sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
                 {
-                    Assert.AreEqual("Okay", lbl.Text);
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.Equal("Okay", lbl.Text);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                     evt.Set();
                 });
             });
@@ -186,7 +186,7 @@ namespace ReactiveTests.Tests
             Application.Exit();
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulePeriodic_ArgumentChecking()
         {
             var s = new ControlScheduler(new Label());
@@ -195,7 +195,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.SchedulePeriodic(42, TimeSpan.FromMilliseconds(1).Subtract(TimeSpan.FromTicks(1)), x => x));
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulePeriodic()
         {
             var evt = new ManualResetEvent(false);
@@ -210,7 +210,7 @@ namespace ReactiveTests.Tests
             d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
             {
                 lbl.Text = "Okay " + n;
-                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                 if (n == 3)
                 {
@@ -218,15 +218,15 @@ namespace ReactiveTests.Tests
 
                     sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
                     {
-                        Assert.AreEqual("Okay 3", lbl.Text);
-                        Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                        Assert.Equal("Okay 3", lbl.Text);
+                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                         evt.Set();
                     });
                 }
 
                 if (n > 3)
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 }
 
                 return n + 1;
@@ -236,7 +236,7 @@ namespace ReactiveTests.Tests
             Application.Exit();
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulePeriodic_Nested()
         {
             var evt = new ManualResetEvent(false);
@@ -255,7 +255,7 @@ namespace ReactiveTests.Tests
                 d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
                 {
                     lbl.Text = "Okay " + n;
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                     if (n == 3)
                     {
@@ -263,8 +263,8 @@ namespace ReactiveTests.Tests
 
                         sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
                         {
-                            Assert.AreEqual("Okay 3", lbl.Text);
-                            Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                            Assert.Equal("Okay 3", lbl.Text);
+                            Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                             evt.Set();
                         });
                     }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/CurrentThreadSchedulerTest.cs

@@ -4,15 +4,15 @@ using System;
 using System.Diagnostics;
 using System.Reactive.Concurrency;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using Microsoft.Reactive.Testing;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class CurrentThreadSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void CurrentThread_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.CurrentThread.Schedule(42, default(Func<IScheduler, int, IDisposable>)));
@@ -20,23 +20,25 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.CurrentThread.Schedule(42, default(DateTimeOffset), default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void CurrentThread_Now()
         {
             var res = Scheduler.CurrentThread.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void CurrentThread_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
-            Scheduler.CurrentThread.Schedule(() => { Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
-            Assert.IsTrue(ran);
+            Scheduler.CurrentThread.Schedule(() => { Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            Assert.True(ran);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void CurrentThread_ScheduleActionError()
         {
             var ex = new Exception();
@@ -44,56 +46,54 @@ namespace ReactiveTests.Tests
             try
             {
                 Scheduler.CurrentThread.Schedule(() => { throw ex; });
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
-                Assert.AreSame(e, ex);
+                Assert.Same(e, ex);
             }
         }
-
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void CurrentThread_ScheduleActionNested()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
             Scheduler.CurrentThread.Schedule(() => {
-                Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.Equal(id, Thread.CurrentThread.ManagedThreadId);
                 Scheduler.CurrentThread.Schedule(() => { ran = true; });
             });
-            Assert.IsTrue(ran);
+            Assert.True(ran);
         }
 
-        [TestMethod]
+        [Fact]
         public void CurrentThread_ScheduleActionNested_TimeSpan()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
             Scheduler.CurrentThread.Schedule(() =>
             {
-                Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.Equal(id, Thread.CurrentThread.ManagedThreadId);
                 Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(1), () => { ran = true; });
             });
-            Assert.IsTrue(ran);
+            Assert.True(ran);
         }
 
 #if !SILVERLIGHT
 
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip ="")]
         public void CurrentThread_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
             var sw = new Stopwatch();
             sw.Start();
-            Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
-            Assert.IsTrue(ran, "ran");
-            Assert.IsTrue(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
+            Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            Assert.True(ran, "ran");
+            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip = "")]
         public void CurrentThread_ScheduleActionDueNested()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -102,18 +102,19 @@ namespace ReactiveTests.Tests
             sw.Start();
             Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () => {
                 sw.Stop();
-                Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.Equal(id, Thread.CurrentThread.ManagedThreadId);
                 sw.Start();
                 Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () => {
                     sw.Stop();
                     ran = true;
                 });
             });
-            Assert.IsTrue(ran, "ran");
-            Assert.IsTrue(sw.ElapsedMilliseconds > 380, "due " + sw.ElapsedMilliseconds);
+            Assert.True(ran, "ran");
+            Assert.True(sw.ElapsedMilliseconds > 380, "due " + sw.ElapsedMilliseconds);
         }
 #endif
-        [TestMethod]
+#endif
+        [Fact]
         public void CurrentThread_EnsureTrampoline()
         {
             var ran1 = false;
@@ -122,11 +123,11 @@ namespace ReactiveTests.Tests
                 Scheduler.CurrentThread.Schedule(() => { ran1 = true; });
                 Scheduler.CurrentThread.Schedule(() => { ran2 = true; });
             });
-            Assert.IsTrue(ran1);
-            Assert.IsTrue(ran2);
+            Assert.True(ran1);
+            Assert.True(ran2);
         }
 
-        [TestMethod]
+        [Fact]
         public void CurrentThread_EnsureTrampoline_Nested()
         {
             var ran1 = false;
@@ -136,11 +137,11 @@ namespace ReactiveTests.Tests
                 Scheduler.CurrentThread.EnsureTrampoline(() => { ran1 = true; });
                 Scheduler.CurrentThread.EnsureTrampoline(() => { ran2 = true; });
             });
-            Assert.IsTrue(ran1);
-            Assert.IsTrue(ran2);
+            Assert.True(ran1);
+            Assert.True(ran2);
         }
 
-        [TestMethod]
+        [Fact]
         public void CurrentThread_EnsureTrampolineAndCancel()
         {
             var ran1 = false;
@@ -153,11 +154,11 @@ namespace ReactiveTests.Tests
                     d.Dispose();
                 });
             });
-            Assert.IsTrue(ran1);
-            Assert.IsFalse(ran2);
+            Assert.True(ran1);
+            Assert.False(ran2);
         }
 
-        [TestMethod]
+        [Fact]
         public void CurrentThread_EnsureTrampolineAndCancelTimed()
         {
             var ran1 = false;
@@ -171,8 +172,8 @@ namespace ReactiveTests.Tests
                     d.Dispose();
                 });
             });
-            Assert.IsTrue(ran1);
-            Assert.IsFalse(ran2);
+            Assert.True(ran1);
+            Assert.False(ran2);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/DefaultSchedulerTest.cs

@@ -4,15 +4,15 @@ using System;
 using System.Reactive.Concurrency;
 using System.Diagnostics;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using Microsoft.Reactive.Testing;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class DefaultSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void Schedule_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule<int>(42, default(Func<IScheduler, int, IDisposable>)));
@@ -22,48 +22,48 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DefaultScheduler.Instance.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [TestMethod]
+        [Fact]
         public void Get_Now()
         {
             var res = DefaultScheduler.Instance.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
-
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = DefaultScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(() => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(() => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
 #if !SILVERLIGHT
-        [TestMethod]
+        [Fact]
         public void ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = DefaultScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void ScheduleActionCancel()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = DefaultScheduler.Instance;
             var set = false;
-            var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.Fail(); set = true; });
+            var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.True(false); set = true; });
             d.Dispose();
             Thread.Sleep(400);
-            Assert.IsFalse(set);
+            Assert.False(set);
         }
 
-        [TestMethod]
+        [Fact]
         public void Periodic_NonReentrant()
         {
             var n = 0;
@@ -89,11 +89,11 @@ namespace ReactiveTests.Tests
             Thread.Sleep(500);
             d.Dispose();
 
-            Assert.IsFalse(fail);
+            Assert.False(fail);
         }
-
+#endif
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void No_ThreadPool_Starvation_Dispose()
         {
             var bwt = default(int);
@@ -116,7 +116,7 @@ namespace ReactiveTests.Tests
             var eio = default(int);
             ThreadPool.GetAvailableThreads(out ewt, out eio);
 
-            Assert.IsFalse(bwt - ewt >= N);
+            Assert.False(bwt - ewt >= N);
         }
 #endif
     }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/DispatcherSchedulerTest.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
+#if NET45
 using System;
 using System.Diagnostics;
 using System.Reactive.Concurrency;
@@ -7,7 +8,7 @@ using System.Reactive.Disposables;
 using System.Threading;
 using System.Windows.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 #if SILVERLIGHT && !SILVERLIGHTM7
 using Microsoft.Silverlight.Testing;
@@ -15,16 +16,16 @@ using Microsoft.Silverlight.Testing;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class DispatcherSchedulerTest : TestBase
     {
-        [TestMethod]
+        [Fact]
         public void Ctor_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new DispatcherScheduler(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Current()
         {
             var d = DispatcherHelpers.EnsureDispatcher();
@@ -39,7 +40,7 @@ namespace ReactiveTests.Tests
             e.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void Current_None()
         {
             var e = default(Exception);
@@ -59,25 +60,25 @@ namespace ReactiveTests.Tests
             t.Start();
             t.Join();
 
-            Assert.IsTrue(e != null && e is InvalidOperationException);
+            Assert.True(e != null && e is InvalidOperationException);
         }
 
-        [TestMethod]
+        [Fact]
         public void Dispatcher()
         {
             var disp = DispatcherHelpers.EnsureDispatcher();
-            Assert.AreSame(disp.Dispatcher, new DispatcherScheduler(disp).Dispatcher);
+            Assert.Same(disp.Dispatcher, new DispatcherScheduler(disp).Dispatcher);
         }
 
-        [TestMethod]
+        [Fact]
         public void Now()
         {
             var disp = DispatcherHelpers.EnsureDispatcher();
             var res = new DispatcherScheduler(disp).Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Schedule_ArgumentChecking()
         {
             var disp = DispatcherHelpers.EnsureDispatcher();
@@ -87,7 +88,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         [Asynchronous]
         public void Schedule()
         {
@@ -100,9 +101,9 @@ namespace ReactiveTests.Tests
                 sch.Schedule(() =>
                 {
 #if SILVERLIGHT
-                    Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); // Single-threaded test framework
+                    Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); // Single-threaded test framework
 #else
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 #endif
                     disp.InvokeShutdown();
                     evt.Set();
@@ -111,7 +112,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !USE_SL_DISPATCHER
-        [TestMethod]
+        [Fact]
         public void ScheduleError()
         {
             var ex = new Exception();
@@ -122,9 +123,9 @@ namespace ReactiveTests.Tests
             disp.UnhandledException += (o, e) =>
             {
 #if DESKTOPCLR40 || DESKTOPCLR45 || DESKTOPCLR46
-                Assert.AreSame(ex, e.Exception); // CHECK
+                Assert.Same(ex, e.Exception); // CHECK
 #else
-                Assert.AreSame(ex, e.Exception.InnerException); // CHECK
+                Assert.Same(ex, e.Exception.InnerException); // CHECK
 #endif
                 evt.Set();
                 e.Handled = true;
@@ -135,13 +136,13 @@ namespace ReactiveTests.Tests
             disp.InvokeShutdown();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative()
         {
             ScheduleRelative_(TimeSpan.FromSeconds(0.2));
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative_Zero()
         {
             ScheduleRelative_(TimeSpan.Zero);
@@ -158,11 +159,11 @@ namespace ReactiveTests.Tests
 
             sch.Schedule(delay, () =>
             {
-                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                 sch.Schedule(delay, () =>
                 {
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                     evt.Set();
                 });
             });
@@ -171,7 +172,7 @@ namespace ReactiveTests.Tests
             disp.InvokeShutdown();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleRelative_Cancel()
         {
             var evt = new ManualResetEvent(false);
@@ -183,11 +184,11 @@ namespace ReactiveTests.Tests
             
             sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
             {
-                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                 var d = sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                     evt.Set();
                 });
 
@@ -198,7 +199,7 @@ namespace ReactiveTests.Tests
 
                 sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
                 {
-                    Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                     evt.Set();
                 });
             });
@@ -207,7 +208,7 @@ namespace ReactiveTests.Tests
             disp.InvokeShutdown();
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulePeriodic_ArgumentChecking()
         {
             var disp = DispatcherHelpers.EnsureDispatcher();
@@ -217,7 +218,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), x => x));
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulePeriodic()
         {
             var evt = new ManualResetEvent(false);
@@ -231,7 +232,7 @@ namespace ReactiveTests.Tests
 
             d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
             {
-                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
 
                 if (n == 3)
                 {
@@ -239,14 +240,14 @@ namespace ReactiveTests.Tests
 
                     sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
                     {
-                        Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
                         evt.Set();
                     });
                 }
 
                 if (n > 3)
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 }
 
                 return n + 1;
@@ -258,3 +259,4 @@ namespace ReactiveTests.Tests
 #endif
     }
 }
+#endif

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/EventLoopSchedulerTest.cs

@@ -7,22 +7,24 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 #if STRESS
 using ReactiveTests.Stress.Schedulers;
 #endif
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class EventLoopSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void EventLoop_ArgumentChecking()
         {
             var el = new EventLoopScheduler();
 
+#if !NO_THREAD
             ReactiveAssert.Throws<ArgumentNullException>(() => new EventLoopScheduler(null));
+#endif
             ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule<int>(42, default(Func<IScheduler, int, IDisposable>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule<int>(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => el.Schedule<int>(42, TimeSpan.Zero, default(Func<IScheduler, int, IDisposable>)));
@@ -30,14 +32,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => el.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_Now()
         {
             var res = new EventLoopScheduler().Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleAction()
         {
             var ran = false;
@@ -45,11 +47,12 @@ namespace ReactiveTests.Tests
             var el = new EventLoopScheduler();
             el.Schedule(() => { ran = true;
                                   gate.Release(); });
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
-            Assert.IsTrue(ran);
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(ran);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void EventLoop_DifferentThread()
         {
             var id = default(int);
@@ -60,11 +63,12 @@ namespace ReactiveTests.Tests
                 id = Thread.CurrentThread.ManagedThreadId;
                 gate.Release();
             });
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
-            Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, id);
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.NotEqual(Thread.CurrentThread.ManagedThreadId, id);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleOrderedActions()
         {
             var results = new List<int>();
@@ -76,11 +80,11 @@ namespace ReactiveTests.Tests
                 results.Add(1);
                 gate.Release();
             });
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
             results.AssertEqual(0, 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_SchedulerDisposed()
         {
             var d = 0;
@@ -126,10 +130,10 @@ namespace ReactiveTests.Tests
 
             results.AssertEqual(0, 1);
 
-            Assert.AreEqual(2, d);
+            Assert.Equal(2, d);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleTimeOrderedActions()
         {
             var results = new List<int>();
@@ -142,11 +146,11 @@ namespace ReactiveTests.Tests
                             gate.Release();
                         });
 
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
             results.AssertEqual(1, 0);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleOrderedAndTimedActions()
         {
             var results = new List<int>();
@@ -159,11 +163,11 @@ namespace ReactiveTests.Tests
                 gate.Release();
             });
 
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
             results.AssertEqual(1, 0);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleTimeOrderedInFlightActions()
         {            
             var results = new List<int>();
@@ -181,11 +185,11 @@ namespace ReactiveTests.Tests
                             });
                         });
 
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
             results.AssertEqual(0, 1, 2);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleTimeAndOrderedInFlightActions()
         {
             var results = new List<int>();
@@ -204,11 +208,11 @@ namespace ReactiveTests.Tests
                 });
             });
 
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
             results.AssertEqual(0, 4, 1, 2);
         }       
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_ScheduleActionNested()
         {
             var ran = false;
@@ -216,13 +220,12 @@ namespace ReactiveTests.Tests
             var gate = new Semaphore(0, 1);
             el.Schedule(() => el.Schedule(() => { ran = true;
                                                   gate.Release(); }));
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
-            Assert.IsTrue(ran);
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(ran);
         }
 
 #if !SILVERLIGHT
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip ="")]
         public void EventLoop_ScheduleActionDue()
         {
             var ran = false;
@@ -235,13 +238,12 @@ namespace ReactiveTests.Tests
                                   sw.Stop();
                                   gate.Release();
                               });
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
-            Assert.IsTrue(ran, "ran");
-            Assert.IsTrue(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(ran, "ran");
+            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip = "")]
         public void EventLoop_ScheduleActionDueNested()
         {
             var ran = false;
@@ -262,15 +264,15 @@ namespace ReactiveTests.Tests
                 });
             });
 
-            Assert.IsTrue(gate.WaitOne(TimeSpan.FromSeconds(2)));
-            Assert.IsTrue(ran, "ran");
-            Assert.IsTrue(sw.ElapsedMilliseconds > 380, "due " + sw.ElapsedMilliseconds);
+            Assert.True(gate.WaitOne(TimeSpan.FromSeconds(2)));
+            Assert.True(ran, "ran");
+            Assert.True(sw.ElapsedMilliseconds > 380, "due " + sw.ElapsedMilliseconds);
         }
 #endif
 
 #if !NO_PERF
 #if !NO_STOPWATCH
-        [TestMethod]
+        [Fact]
         public void Stopwatch()
         {
             StopwatchTest.Run(new EventLoopScheduler());
@@ -279,7 +281,7 @@ namespace ReactiveTests.Tests
 #endif
 
 #if !NO_CDS
-        [TestMethod]
+        [Fact]
         public void EventLoop_Immediate()
         {
             var M = 1000;
@@ -299,14 +301,14 @@ namespace ReactiveTests.Tests
                                 d.Add(e.Schedule(() => cd.Signal()));
 
                             if (!cd.Wait(10000))
-                                Assert.Fail("j = " + j);
+                                Assert.True(false, "j = " + j);
                         }
                     }
                 }
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_TimeCollisions()
         {
             var M = 1000;
@@ -326,14 +328,14 @@ namespace ReactiveTests.Tests
                                 d.Add(e.Schedule(TimeSpan.FromMilliseconds(100), () => cd.Signal()));
 
                             if (!cd.Wait(10000))
-                                Assert.Fail("j = " + j);
+                                Assert.True(false, "j = " + j);
                         }
                     }
                 }
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_Spread()
         {
             var M = 1000;
@@ -353,7 +355,7 @@ namespace ReactiveTests.Tests
                                 d.Add(e.Schedule(TimeSpan.FromMilliseconds(k), () => cd.Signal()));
 
                             if (!cd.Wait(10000))
-                                Assert.Fail("j = " + j);
+                                Assert.True(false, "j = " + j);
                         }
                     }
                 }
@@ -361,7 +363,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void EventLoop_Periodic()
         {
             var n = 0;
@@ -377,14 +379,14 @@ namespace ReactiveTests.Tests
                 });
                 
                 if (!e.WaitOne(10000))
-                    Assert.Fail();
+                    Assert.True(false);
                 
                 d.Dispose();
             }
         }
 
 #if STRESS
-        [TestMethod]
+        [Fact]
         public void EventLoop_Stress()
         {
             EventLoop.NoSemaphoreFullException();
@@ -392,7 +394,7 @@ namespace ReactiveTests.Tests
 #endif
 
 #if !NO_CDS && DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void EventLoop_CorrectWorkStealing()
         {
             const int workItemCount = 100;
@@ -427,7 +429,7 @@ namespace ReactiveTests.Tests
                 countdown.Wait();
             }
 
-            Assert.AreEqual(0, failureCount);
+            Assert.Equal(0, failureCount);
         }
 #endif
     }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/HistoricalSchedulerTest.cs

@@ -6,11 +6,11 @@ using System.Linq;
 using System.Reactive;
 using System.Reactive.Concurrency;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class HistoricalSchedulerTest
     {
         public DateTimeOffset Time(int i)
@@ -18,17 +18,17 @@ namespace ReactiveTests.Tests
             return new DateTimeOffset(1979, 10, 31, 4, 30, 15, TimeSpan.Zero).AddDays(i);
         }
 
-        [TestMethod]
+        [Fact]
         public void Ctor()
         {
             var s = new HistoricalScheduler();
 
-            Assert.AreEqual(DateTimeOffset.MinValue, s.Clock);
-            Assert.AreEqual(DateTimeOffset.MinValue, s.Now);
-            Assert.AreEqual(false, s.IsEnabled);
+            Assert.Equal(DateTimeOffset.MinValue, s.Clock);
+            Assert.Equal(DateTimeOffset.MinValue, s.Now);
+            Assert.Equal(false, s.IsEnabled);
         }
 
-        [TestMethod]
+        [Fact]
         public void Start_Stop()
         {
             var s = new HistoricalScheduler();
@@ -47,23 +47,23 @@ namespace ReactiveTests.Tests
 
             s.Start();
 
-            Assert.AreEqual(Time(2), s.Now);
-            Assert.AreEqual(Time(2), s.Clock);
+            Assert.Equal(Time(2), s.Now);
+            Assert.Equal(Time(2), s.Clock);
 
             s.Start();
 
-            Assert.AreEqual(Time(4), s.Now);
-            Assert.AreEqual(Time(4), s.Clock);
+            Assert.Equal(Time(4), s.Now);
+            Assert.Equal(Time(4), s.Clock);
 
             s.Start();
 
-            Assert.AreEqual(Time(6), s.Now);
-            Assert.AreEqual(Time(6), s.Clock);
+            Assert.Equal(Time(6), s.Now);
+            Assert.Equal(Time(6), s.Clock);
 
             s.Start();
 
-            Assert.AreEqual(Time(6), s.Now);
-            Assert.AreEqual(Time(6), s.Clock);
+            Assert.Equal(Time(6), s.Now);
+            Assert.Equal(Time(6), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(1, Time(0)),
@@ -73,7 +73,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Order()
         {
             var s = new HistoricalScheduler();
@@ -97,7 +97,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Cancellation()
         {
             var s = new HistoricalScheduler();
@@ -119,7 +119,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void AdvanceTo_ArgumentChecking()
         {
             var now = DateTimeOffset.Now;
@@ -129,7 +129,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.AdvanceTo(now.Subtract(TimeSpan.FromSeconds(1))));
         }
 
-        [TestMethod]
+        [Fact]
         public void AdvanceTo()
         {
             var s = new HistoricalScheduler();
@@ -144,8 +144,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceTo(Time(8));
 
-            Assert.AreEqual(Time(8), s.Now);
-            Assert.AreEqual(Time(8), s.Clock);
+            Assert.Equal(Time(8), s.Now);
+            Assert.Equal(Time(8), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -155,8 +155,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceTo(Time(8));
 
-            Assert.AreEqual(Time(8), s.Now);
-            Assert.AreEqual(Time(8), s.Clock);
+            Assert.Equal(Time(8), s.Now);
+            Assert.Equal(Time(8), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -169,8 +169,8 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.AdvanceTo(Time(4)));
 
-            Assert.AreEqual(Time(8), s.Now);
-            Assert.AreEqual(Time(8), s.Clock);
+            Assert.Equal(Time(8), s.Now);
+            Assert.Equal(Time(8), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -180,8 +180,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceTo(Time(10));
 
-            Assert.AreEqual(Time(10), s.Now);
-            Assert.AreEqual(Time(10), s.Clock);
+            Assert.Equal(Time(10), s.Now);
+            Assert.Equal(Time(10), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -194,8 +194,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceTo(Time(100));
 
-            Assert.AreEqual(Time(100), s.Now);
-            Assert.AreEqual(Time(100), s.Clock);
+            Assert.Equal(Time(100), s.Now);
+            Assert.Equal(Time(100), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -208,7 +208,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void AdvanceBy_ArgumentChecking()
         {
             var s = new HistoricalScheduler();
@@ -216,7 +216,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.AdvanceBy(TimeSpan.FromSeconds(-1)));
         }
 
-        [TestMethod]
+        [Fact]
         public void AdvanceBy()
         {
             var s = new HistoricalScheduler();
@@ -231,8 +231,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceBy(Time(8) - s.Now);
 
-            Assert.AreEqual(Time(8), s.Now);
-            Assert.AreEqual(Time(8), s.Clock);
+            Assert.Equal(Time(8), s.Now);
+            Assert.Equal(Time(8), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -245,8 +245,8 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.AdvanceBy(TimeSpan.FromDays(-4)));
 
-            Assert.AreEqual(Time(8), s.Now);
-            Assert.AreEqual(Time(8), s.Clock);
+            Assert.Equal(Time(8), s.Now);
+            Assert.Equal(Time(8), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -256,8 +256,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceBy(TimeSpan.Zero);
 
-            Assert.AreEqual(Time(8), s.Now);
-            Assert.AreEqual(Time(8), s.Clock);
+            Assert.Equal(Time(8), s.Now);
+            Assert.Equal(Time(8), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -267,8 +267,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceBy(TimeSpan.FromDays(2));
 
-            Assert.AreEqual(Time(10), s.Now);
-            Assert.AreEqual(Time(10), s.Clock);
+            Assert.Equal(Time(10), s.Now);
+            Assert.Equal(Time(10), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -281,8 +281,8 @@ namespace ReactiveTests.Tests
 
             s.AdvanceBy(TimeSpan.FromDays(90));
 
-            Assert.AreEqual(Time(100), s.Now);
-            Assert.AreEqual(Time(100), s.Clock);
+            Assert.Equal(Time(100), s.Now);
+            Assert.Equal(Time(100), s.Clock);
 
             list.AssertEqual(
                 new Timestamped<int>(0, Time(0)),
@@ -295,28 +295,28 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void IsEnabled()
         {
             var s = new HistoricalScheduler();
 
-            Assert.AreEqual(false, s.IsEnabled);
+            Assert.Equal(false, s.IsEnabled);
 
             s.Schedule(() =>
             {
-                Assert.AreEqual(true, s.IsEnabled);
+                Assert.Equal(true, s.IsEnabled);
                 s.Stop();
-                Assert.AreEqual(false, s.IsEnabled);
+                Assert.Equal(false, s.IsEnabled);
             });
 
-            Assert.AreEqual(false, s.IsEnabled);
+            Assert.Equal(false, s.IsEnabled);
 
             s.Start();
 
-            Assert.AreEqual(false, s.IsEnabled);
+            Assert.Equal(false, s.IsEnabled);
         }
 
-        [TestMethod]
+        [Fact]
         public void No_Nested_AdvanceBy()
         {
             var s = new HistoricalScheduler();
@@ -326,7 +326,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => s.Start());
         }
 
-        [TestMethod]
+        [Fact]
         public void No_Nested_AdvanceTo()
         {
             var s = new HistoricalScheduler();
@@ -336,7 +336,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => s.Start());
         }
 
-        [TestMethod]
+        [Fact]
         public void Sleep_ArgumentChecking()
         {
             var s = new HistoricalScheduler(DateTimeOffset.Now);
@@ -344,7 +344,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.Sleep(TimeSpan.FromSeconds(-1)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Sleep1()
         {
             var now = new DateTimeOffset(1983, 2, 11, 12, 0, 0, TimeSpan.Zero);
@@ -353,10 +353,10 @@ namespace ReactiveTests.Tests
 
             s.Sleep(TimeSpan.FromDays(1));
 
-            Assert.AreEqual(now + TimeSpan.FromDays(1), s.Clock);
+            Assert.Equal(now + TimeSpan.FromDays(1), s.Clock);
         }
 
-        [TestMethod]
+        [Fact]
         public void Sleep2()
         {
             var s = new HistoricalScheduler();
@@ -373,16 +373,16 @@ namespace ReactiveTests.Tests
 
             s.AdvanceTo(s.Now + TimeSpan.FromMinutes(5));
 
-            Assert.AreEqual(2, n);
+            Assert.Equal(2, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void WithComparer_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new HistoricalScheduler(DateTimeOffset.Now, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void WithComparer()
         {
             var now = DateTimeOffset.Now;
@@ -396,7 +396,7 @@ namespace ReactiveTests.Tests
 
             s.Start();
 
-            Assert.IsTrue(new[] { 1, 2 }.SequenceEqual(res));
+            Assert.True(new[] { 1, 2 }.SequenceEqual(res));
         }
 
         class ReverseComparer<T> : IComparer<T>

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs

@@ -6,30 +6,31 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ImmediateSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void Immediate_Now()
         {
             var res = Scheduler.Immediate.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
-
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void Immediate_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
-            Scheduler.Immediate.Schedule(() => { Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
-            Assert.IsTrue(ran);
+            Scheduler.Immediate.Schedule(() => { Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            Assert.True(ran);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void Immediate_ScheduleActionError()
         {
             var ex = new Exception();
@@ -37,15 +38,15 @@ namespace ReactiveTests.Tests
             try
             {
                 Scheduler.Immediate.Schedule(() => { throw ex; });
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
-                Assert.AreSame(e, ex);
+                Assert.Same(e, ex);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule<int>(42, default(Func<IScheduler, int, IDisposable>)));
@@ -53,61 +54,61 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule<int>(42, TimeSpan.Zero, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_Simple1()
         {
             var _x = 0;
             Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return Disposable.Empty; });
-            Assert.AreEqual(42, _x);
+            Assert.Equal(42, _x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_Simple2()
         {
             var _x = 0;
             Scheduler.Immediate.Schedule<int>(42, DateTimeOffset.Now, (self, x) => { _x = x; return Disposable.Empty; });
-            Assert.AreEqual(42, _x);
+            Assert.Equal(42, _x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_Simple3()
         {
             var _x = 0;
             Scheduler.Immediate.Schedule<int>(42, TimeSpan.Zero, (self, x) => { _x = x; return Disposable.Empty; });
-            Assert.AreEqual(42, _x);
+            Assert.Equal(42, _x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_Recursive1()
         {
             var _x = 0;
             var _y = 0;
             Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return self.Schedule<int>(43, (self2, y) => { _y = y; return Disposable.Empty; }); });
-            Assert.AreEqual(42, _x);
-            Assert.AreEqual(43, _y);
+            Assert.Equal(42, _x);
+            Assert.Equal(43, _y);
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_Recursive2()
         {
             var _x = 0;
             var _y = 0;
             Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return self.Schedule<int>(43, DateTimeOffset.Now, (self2, y) => { _y = y; return Disposable.Empty; }); });
-            Assert.AreEqual(42, _x);
-            Assert.AreEqual(43, _y);
+            Assert.Equal(42, _x);
+            Assert.Equal(43, _y);
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_Recursive3()
         {
             var _x = 0;
             var _y = 0;
             Scheduler.Immediate.Schedule<int>(42, (self, x) => { _x = x; return self.Schedule<int>(43, TimeSpan.FromMilliseconds(100), (self2, y) => { _y = y; return Disposable.Empty; }); });
-            Assert.AreEqual(42, _x);
-            Assert.AreEqual(43, _y);
+            Assert.Equal(42, _x);
+            Assert.Equal(43, _y);
         }
 
-        [TestMethod]
+        [Fact]
         public void Immediate_ArgumentChecking_More()
         {
             Scheduler.Immediate.Schedule(42, (self, state) =>
@@ -141,18 +142,17 @@ namespace ReactiveTests.Tests
             });
         }
 
-#if !SILVERLIGHT
-        [TestMethod]
-        [Ignore]
+#if !SILVERLIGHT && !NO_THREAD
+        [Fact(Skip="Ignored")]        
         public void Immediate_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
             var sw = new Stopwatch();
             sw.Start();
-            Scheduler.Immediate.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
-            Assert.IsTrue(ran, "ran");
-            Assert.IsTrue(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
+            Scheduler.Immediate.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            Assert.True(ran, "ran");
+            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 #endif
     }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs

@@ -6,14 +6,14 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+#if !NO_THREAD
     public class NewThreadSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void NewThread_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new NewThreadScheduler(null));
@@ -25,26 +25,25 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => NewThreadScheduler.Default.SchedulePeriodic<int>(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [TestMethod]
+        [Fact]
         public void NewThread_Now()
         {
             var res = NewThreadScheduler.Default.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
-
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void NewThread_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = NewThreadScheduler.Default;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(() => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(() => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
 #if !SILVERLIGHT
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip = "")]
         public void NewThread_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -52,15 +51,16 @@ namespace ReactiveTests.Tests
             var evt = new ManualResetEvent(false);
             var sw = new Stopwatch();
             sw.Start();
-            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
-            Assert.IsTrue(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
+            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 #endif
+#endif
 
 #if !NO_PERF
 #if !NO_STOPWATCH
-        [TestMethod]
+        [Fact]
         public void Stopwatch()
         {
             StopwatchTest.Run(NewThreadScheduler.Default);
@@ -68,7 +68,7 @@ namespace ReactiveTests.Tests
 #endif
 #endif
 
-        [TestMethod]
+        [Fact]
         public void NewThread_Periodic()
         {
             var n = 0;
@@ -81,12 +81,13 @@ namespace ReactiveTests.Tests
             });
 
             if (!e.WaitOne(10000))
-                Assert.Fail();
+                Assert.True(false);
 
             d.Dispose();
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void NewThread_Periodic_NonReentrant()
         {
             var n = 0;
@@ -112,7 +113,9 @@ namespace ReactiveTests.Tests
             Thread.Sleep(500);
             d.Dispose();
 
-            Assert.IsFalse(fail);
+            Assert.False(fail);
         }
+#endif
     }
+#endif
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/ScheduledItemTest.cs

@@ -5,14 +5,14 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests
 {
-    [TestClass]
+    
     public class ScheduledItemTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledItem<DateTimeOffset, int>(default(IScheduler), 42, (x, y) => Disposable.Empty, DateTimeOffset.Now));
@@ -23,61 +23,61 @@ namespace ReactiveTests
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledItem<DateTimeOffset, int>(Scheduler.Default, 42, (x, y) => Disposable.Empty, DateTimeOffset.Now, default(IComparer<DateTimeOffset>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Inequalities()
         {
             var si1 = new SI(42);
             var si2 = new SI(43);
             var si3 = new SI(42);
 
-            Assert.IsTrue(si1 < si2);
-            Assert.IsFalse(si1 < si3);
-            Assert.IsTrue(si1 <= si2);
-            Assert.IsTrue(si1 <= si3);
-            Assert.IsTrue(si2 > si1);
-            Assert.IsFalse(si3 > si1);
-            Assert.IsTrue(si2 >= si1);
-            Assert.IsTrue(si3 >= si1);
-
-            Assert.IsTrue(si1.CompareTo(si2) < 0);
-            Assert.IsTrue(si2.CompareTo(si1) > 0);
-            Assert.IsTrue(si1.CompareTo(si1) == 0);
-            Assert.IsTrue(si1.CompareTo(si3) == 0);
-
-            Assert.IsTrue(si2 > null);
-            Assert.IsTrue(si2 >= null);
-            Assert.IsFalse(si2 < null);
-            Assert.IsFalse(si2 <= null);
-            Assert.IsTrue(null < si1);
-            Assert.IsTrue(null <= si1);
-            Assert.IsFalse(null > si1);
-            Assert.IsFalse(null >= si1);
-
-            Assert.IsTrue(si1.CompareTo(null) > 0);
+            Assert.True(si1 < si2);
+            Assert.False(si1 < si3);
+            Assert.True(si1 <= si2);
+            Assert.True(si1 <= si3);
+            Assert.True(si2 > si1);
+            Assert.False(si3 > si1);
+            Assert.True(si2 >= si1);
+            Assert.True(si3 >= si1);
+
+            Assert.True(si1.CompareTo(si2) < 0);
+            Assert.True(si2.CompareTo(si1) > 0);
+            Assert.True(si1.CompareTo(si1) == 0);
+            Assert.True(si1.CompareTo(si3) == 0);
+
+            Assert.True(si2 > null);
+            Assert.True(si2 >= null);
+            Assert.False(si2 < null);
+            Assert.False(si2 <= null);
+            Assert.True(null < si1);
+            Assert.True(null <= si1);
+            Assert.False(null > si1);
+            Assert.False(null >= si1);
+
+            Assert.True(si1.CompareTo(null) > 0);
 
             var si4 = new SI2(43, -1);
             var si5 = new SI2(44, -1);
 
-            Assert.IsTrue(si4 > si1);
-            Assert.IsTrue(si4 >= si1);
-            Assert.IsTrue(si1 < si4);
-            Assert.IsTrue(si1 <= si4);
-            Assert.IsFalse(si4 > si2);
-            Assert.IsTrue(si4 >= si2);
-            Assert.IsFalse(si2 < si4);
-            Assert.IsTrue(si2 <= si4);
-
-            Assert.IsTrue(si5 > si4);
-            Assert.IsTrue(si5 >= si4);
-            Assert.IsFalse(si4 > si5);
-            Assert.IsFalse(si4 >= si5);
-            Assert.IsTrue(si4 < si5);
-            Assert.IsTrue(si4 <= si5);
-            Assert.IsFalse(si5 < si4);
-            Assert.IsFalse(si5 <= si4);
+            Assert.True(si4 > si1);
+            Assert.True(si4 >= si1);
+            Assert.True(si1 < si4);
+            Assert.True(si1 <= si4);
+            Assert.False(si4 > si2);
+            Assert.True(si4 >= si2);
+            Assert.False(si2 < si4);
+            Assert.True(si2 <= si4);
+
+            Assert.True(si5 > si4);
+            Assert.True(si5 >= si4);
+            Assert.False(si4 > si5);
+            Assert.False(si4 >= si5);
+            Assert.True(si4 < si5);
+            Assert.True(si4 <= si5);
+            Assert.False(si5 < si4);
+            Assert.False(si5 <= si4);
         }
 
-        [TestMethod]
+        [Fact]
         public void Equalities()
         {
             var si1 = new SI2(42, 123);
@@ -86,23 +86,23 @@ namespace ReactiveTests
             var si4 = new SI2(43, 123);
 
 #pragma warning disable 1718
-            Assert.IsFalse(si1 != si1);
-            Assert.IsTrue(si1 == si1);
+            Assert.False(si1 != si1);
+            Assert.True(si1 == si1);
 #pragma warning restore 1718
-            Assert.IsTrue(si1.Equals(si1));
+            Assert.True(si1.Equals(si1));
 
-            Assert.IsTrue(si1 != si2);
-            Assert.IsFalse(si1 == si2);
-            Assert.IsFalse(si1.Equals(si2));
+            Assert.True(si1 != si2);
+            Assert.False(si1 == si2);
+            Assert.False(si1.Equals(si2));
 
-            Assert.IsTrue(si1 != null);
-            Assert.IsTrue(null != si1);
-            Assert.IsFalse(si1 == null);
-            Assert.IsFalse(null == si1);
+            Assert.True(si1 != null);
+            Assert.True(null != si1);
+            Assert.False(si1 == null);
+            Assert.False(null == si1);
 
-            Assert.AreEqual(si1.GetHashCode(), si1.GetHashCode());
-            Assert.AreNotEqual(si1.GetHashCode(), si2.GetHashCode());
-            Assert.AreNotEqual(si1.GetHashCode(), si3.GetHashCode());
+            Assert.Equal(si1.GetHashCode(), si1.GetHashCode());
+            Assert.NotEqual(si1.GetHashCode(), si2.GetHashCode());
+            Assert.NotEqual(si1.GetHashCode(), si3.GetHashCode());
         }
 
         class SI : ScheduledItem<int>

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
+#if NET45
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -9,7 +10,7 @@ using System.Reactive.Linq;
 using System.Reactive.PlatformServices;
 using System.Runtime.CompilerServices;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using Microsoft.Reactive.Testing;
 
 #if HAS_WINFORMS
@@ -22,12 +23,12 @@ using System.Threading.Tasks;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class SchedulerTest : ReactiveTest
     {
         #region IScheduler
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ArgumentChecks()
         {
             var ms = new MyScheduler();
@@ -48,7 +49,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Schedule(ms, 1, TimeSpan.Zero, default(Action<int, Action<int, TimeSpan>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Schedulers_ArgumentChecks()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.CurrentThread.Schedule(default(Action)));
@@ -85,69 +86,69 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new SynchronizationContextScheduler(ctx).Schedule(DateTimeOffset.MaxValue, default(Action)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ScheduleNonRecursive()
         {
             var ms = new MyScheduler();
             var res = false;
             Scheduler.Schedule(ms, a => { res = true; });
-            Assert.IsTrue(res);
+            Assert.True(res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ScheduleRecursive()
         {
             var ms = new MyScheduler();
             var i = 0;
             Scheduler.Schedule(ms, a => { if (++i < 10) a(); });
-            Assert.AreEqual(10, i);
+            Assert.Equal(10, i);
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ScheduleWithTimeNonRecursive()
         {
             var now = DateTimeOffset.Now;
-            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.IsTrue(t == TimeSpan.Zero); } };
+            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.True(t == TimeSpan.Zero); } };
             var res = false;
             Scheduler.Schedule(ms, now, a => { res = true; });
-            Assert.IsTrue(res);
-            Assert.IsTrue(ms.WaitCycles == 0);
+            Assert.True(res);
+            Assert.True(ms.WaitCycles == 0);
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ScheduleWithTimeRecursive()
         {
             var now = DateTimeOffset.Now;
             var i = 0;
-            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.IsTrue(t == TimeSpan.Zero); } };
+            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.True(t == TimeSpan.Zero); } };
             Scheduler.Schedule(ms, now, a => { if (++i < 10) a(now); });
-            Assert.IsTrue(ms.WaitCycles == 0);
-            Assert.AreEqual(10, i);
+            Assert.True(ms.WaitCycles == 0);
+            Assert.Equal(10, i);
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ScheduleWithTimeSpanNonRecursive()
         {
             var now = DateTimeOffset.Now;
-            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.IsTrue(t == TimeSpan.Zero); } };
+            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.True(t == TimeSpan.Zero); } };
             var res = false;
             Scheduler.Schedule(ms, TimeSpan.Zero, a => { res = true; });
-            Assert.IsTrue(res);
-            Assert.IsTrue(ms.WaitCycles == 0);
+            Assert.True(res);
+            Assert.True(ms.WaitCycles == 0);
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_ScheduleWithTimeSpanRecursive()
         {
             var now = DateTimeOffset.Now;
-            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.IsTrue(t < TimeSpan.FromTicks(10)); } };
+            var ms = new MyScheduler(now) { Check = (a, s, t) => { Assert.True(t < TimeSpan.FromTicks(10)); } };
             var i = 0;
             Scheduler.Schedule(ms, TimeSpan.Zero, a => { if (++i < 10) a(TimeSpan.FromTicks(i)); });
-            Assert.IsTrue(ms.WaitCycles == Enumerable.Range(1, 9).Sum());
-            Assert.AreEqual(10, i);
+            Assert.True(ms.WaitCycles == Enumerable.Range(1, 9).Sum());
+            Assert.Equal(10, i);
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_StateThreading()
         {
             var lst = new List<int>();
@@ -158,10 +159,10 @@ namespace ReactiveTests.Tests
                     a(i + 1);
             });
 
-            Assert.IsTrue(lst.SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_Builtins()
         {
             // Default
@@ -213,14 +214,14 @@ namespace ReactiveTests.Tests
         #region ISchedulerLongRunning
 
 #if !NO_PERF
-        [TestMethod]
+        [Fact]
         public void Scheduler_LongRunning_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.ScheduleLongRunning(null, c => { }));
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.ScheduleLongRunning(ThreadPoolScheduler.Instance, default(Action<ICancelable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_Periodic_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(null, TimeSpan.FromSeconds(1), () => { }));
@@ -236,14 +237,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic<int>(ThreadPoolScheduler.Instance, 42, TimeSpan.FromSeconds(1), default(Func<int, int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_Stopwatch_Emulation()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.StartStopwatch(null));
         }
 
 #if !NO_TPL
-        [TestMethod]
+        [Fact]
         public void Scheduler_LongRunning1()
         {
             var s = TaskPoolScheduler.Default;
@@ -264,7 +265,7 @@ namespace ReactiveTests.Tests
             e.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_LongRunning2()
         {
             var s = TaskPoolScheduler.Default;
@@ -292,7 +293,7 @@ namespace ReactiveTests.Tests
         #region ISchedulerPeriodic
 
 #if !NO_PERF
-        [TestMethod]
+        [Fact]
         public void Scheduler_Periodic1()
         {
             var n = 0;
@@ -308,7 +309,7 @@ namespace ReactiveTests.Tests
             d.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void Scheduler_Periodic2()
         {
             var n = 0;
@@ -316,7 +317,7 @@ namespace ReactiveTests.Tests
 
             var d = ThreadPoolScheduler.Instance.SchedulePeriodic(42, TimeSpan.FromMilliseconds(50), x =>
             {
-                Assert.AreEqual(42, x);
+                Assert.Equal(42, x);
 
                 if (n++ == 10)
                     e.Set();
@@ -327,7 +328,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void Scheduler_Periodic_HostLifecycleManagement()
         {
             var cur = AppDomain.CurrentDomain.BaseDirectory;
@@ -429,7 +430,7 @@ namespace ReactiveTests.Tests
         #region DisableOptimizations
 
 #if !NO_PERF
-        [TestMethod]
+        [Fact]
         public void DisableOptimizations_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.DisableOptimizations(default(IScheduler)));
@@ -442,16 +443,16 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_TPL
-        [TestMethod]
+        [Fact]
         public void DisableOptimizations1()
         {
             var s = TaskPoolScheduler.Default;
-            Assert.IsTrue(s is IServiceProvider);
+            Assert.True(s is IServiceProvider);
 
             var t = s.DisableOptimizations();
 
             var d = t.Now - s.Now;
-            Assert.IsTrue(d.TotalSeconds < 1);
+            Assert.True(d.TotalSeconds < 1);
 
             var e1 = new ManualResetEvent(false);
             t.Schedule(42, (self, state) =>
@@ -478,22 +479,22 @@ namespace ReactiveTests.Tests
             e3.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void DisableOptimizations2()
         {
             var s = TaskPoolScheduler.Default;
-            Assert.IsTrue(s is IServiceProvider);
+            Assert.True(s is IServiceProvider);
 
             var lr1 = ((IServiceProvider)s).GetService(typeof(ISchedulerLongRunning));
-            Assert.IsNotNull(lr1);
+            Assert.NotNull(lr1);
 
             var e1 = new ManualResetEvent(false);
             s.Schedule(42, (self, state) =>
             {
-                Assert.IsTrue(self is IServiceProvider);
+                Assert.True(self is IServiceProvider);
 
                 var lrr1 = ((IServiceProvider)self).GetService(typeof(ISchedulerLongRunning));
-                Assert.IsNotNull(lrr1);
+                Assert.NotNull(lrr1);
 
                 e1.Set();
                 return Disposable.Empty;
@@ -501,18 +502,18 @@ namespace ReactiveTests.Tests
             e1.WaitOne();
 
             var t = s.DisableOptimizations();
-            Assert.IsTrue(t is IServiceProvider);
+            Assert.True(t is IServiceProvider);
 
             var lr2 = ((IServiceProvider)t).GetService(typeof(ISchedulerLongRunning));
-            Assert.IsNull(lr2);
+            Assert.Null(lr2);
 
             var e2 = new ManualResetEvent(false);
             t.Schedule(42, (self, state) =>
             {
-                Assert.IsTrue(self is IServiceProvider);
+                Assert.True(self is IServiceProvider);
 
                 var lrr2 = ((IServiceProvider)self).GetService(typeof(ISchedulerLongRunning));
-                Assert.IsNull(lrr2);
+                Assert.Null(lrr2);
 
                 e2.Set();
                 return Disposable.Empty;
@@ -520,28 +521,28 @@ namespace ReactiveTests.Tests
             e2.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void DisableOptimizations3()
         {
             var s = TaskPoolScheduler.Default;
-            Assert.IsTrue(s is IServiceProvider);
+            Assert.True(s is IServiceProvider);
 
             var lr1 = ((IServiceProvider)s).GetService(typeof(ISchedulerLongRunning));
-            Assert.IsNotNull(lr1);
+            Assert.NotNull(lr1);
 
             var p1 = ((IServiceProvider)s).GetService(typeof(ISchedulerPeriodic));
-            Assert.IsNotNull(p1);
+            Assert.NotNull(p1);
 
             var e1 = new ManualResetEvent(false);
             s.Schedule(42, (self, state) =>
             {
-                Assert.IsTrue(self is IServiceProvider);
+                Assert.True(self is IServiceProvider);
 
                 var lrr1 = ((IServiceProvider)self).GetService(typeof(ISchedulerLongRunning));
-                Assert.IsNotNull(lrr1);
+                Assert.NotNull(lrr1);
 
                 var pr1 = ((IServiceProvider)self).GetService(typeof(ISchedulerPeriodic));
-                Assert.IsNotNull(pr1);
+                Assert.NotNull(pr1);
 
                 e1.Set();
                 return Disposable.Empty;
@@ -549,24 +550,24 @@ namespace ReactiveTests.Tests
             e1.WaitOne();
 
             var t = s.DisableOptimizations(typeof(ISchedulerLongRunning));
-            Assert.IsTrue(t is IServiceProvider);
+            Assert.True(t is IServiceProvider);
 
             var lr2 = ((IServiceProvider)t).GetService(typeof(ISchedulerLongRunning));
-            Assert.IsNull(lr2);
+            Assert.Null(lr2);
 
             var p2 = ((IServiceProvider)t).GetService(typeof(ISchedulerPeriodic));
-            Assert.IsNotNull(p2);
+            Assert.NotNull(p2);
 
             var e2 = new ManualResetEvent(false);
             t.Schedule(42, (self, state) =>
             {
-                Assert.IsTrue(self is IServiceProvider);
+                Assert.True(self is IServiceProvider);
 
                 var lrr2 = ((IServiceProvider)self).GetService(typeof(ISchedulerLongRunning));
-                Assert.IsNull(lrr2);
+                Assert.Null(lrr2);
 
                 var pr2 = ((IServiceProvider)self).GetService(typeof(ISchedulerPeriodic));
-                Assert.IsNotNull(pr2);
+                Assert.NotNull(pr2);
 
                 e2.Set();
                 return Disposable.Empty;
@@ -576,15 +577,15 @@ namespace ReactiveTests.Tests
 #endif
 #endif
 
-        [TestMethod]
+        [Fact]
         public void DisableOptimizations_UnknownService()
         {
             var s = new MyScheduler();
-            Assert.IsFalse(s is IServiceProvider);
+            Assert.False(s is IServiceProvider);
 
             var d = s.DisableOptimizations();
-            Assert.IsTrue(d is IServiceProvider);
-            Assert.IsNull(((IServiceProvider)d).GetService(typeof(bool)));
+            Assert.True(d is IServiceProvider);
+            Assert.Null(((IServiceProvider)d).GetService(typeof(bool)));
         }
 
         class MyScheduler : IScheduler
@@ -630,7 +631,7 @@ namespace ReactiveTests.Tests
 
         #region Catch
 
-        [TestMethod]
+        [Fact]
         public void Catch_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Catch<Exception>(default(IScheduler), _ => true));
@@ -641,7 +642,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Catch<Exception>(Scheduler.Default, _ => true).Schedule(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Builtin_Swallow_Shallow()
         {
             var done = new ManualResetEvent(false);
@@ -656,7 +657,7 @@ namespace ReactiveTests.Tests
             done.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Builtin_Swallow_Recursive()
         {
             var done = new ManualResetEvent(false);
@@ -674,7 +675,7 @@ namespace ReactiveTests.Tests
             done.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_Unhandled()
         {
             var err = default(Exception);
@@ -684,17 +685,17 @@ namespace ReactiveTests.Tests
             {
                 throw new InvalidOperationException();
             });
-            Assert.IsNull(err);
+            Assert.Null(err);
 
             var ex = new ArgumentException();
             scheduler.Catch<InvalidOperationException>(_ => true).Schedule(() =>
             {
                 throw ex;
             });
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_Rethrow()
         {
             var err = default(Exception);
@@ -705,10 +706,10 @@ namespace ReactiveTests.Tests
             {
                 throw ex;
             });
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_LongRunning_Caught()
         {
             var err = default(Exception);
@@ -722,18 +723,18 @@ namespace ReactiveTests.Tests
             {
                 throw new InvalidOperationException();
             });
-            Assert.IsTrue(caught);
-            Assert.IsNull(err);
+            Assert.True(caught);
+            Assert.Null(err);
 
             var ex = new ArgumentException();
             slr.ScheduleLongRunning(cancel =>
             {
                 throw ex;
             });
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_LongRunning_Rethrow()
         {
             var err = default(Exception);
@@ -747,17 +748,17 @@ namespace ReactiveTests.Tests
             {
                 done = true;
             });
-            Assert.IsTrue(done);
+            Assert.True(done);
 
             var ex = new InvalidOperationException();
             slr.ScheduleLongRunning(cancel =>
             {
                 throw ex;
             });
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_Periodic_Regular()
         {
             var scheduler = new MyExceptionScheduler(_ => { });
@@ -780,7 +781,7 @@ namespace ReactiveTests.Tests
             scheduler.PeriodicStopped.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_Periodic_Uncaught1()
         {
             var err = default(Exception);
@@ -799,10 +800,10 @@ namespace ReactiveTests.Tests
 
             scheduler.PeriodicStopped.WaitOne();
             done.WaitOne();
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_Periodic_Uncaught2()
         {
             var err = default(Exception);
@@ -821,10 +822,10 @@ namespace ReactiveTests.Tests
 
             scheduler.PeriodicStopped.WaitOne();
             done.WaitOne();
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Catch_Custom_Periodic_Caught()
         {
             var err = default(Exception);
@@ -842,7 +843,7 @@ namespace ReactiveTests.Tests
 
             scheduler.PeriodicStopped.WaitOne();
             caught.WaitOne();
-            Assert.IsNull(err);
+            Assert.Null(err);
         }
 
         class MyExceptionScheduler : LocalScheduler, ISchedulerLongRunning, ISchedulerPeriodic
@@ -925,11 +926,11 @@ namespace ReactiveTests.Tests
 
         #region Services
 
-        [TestMethod]
+        [Fact]
         public void InvalidService_Null()
         {
             var s = new MySchedulerWithoutServices();
-            Assert.IsNull(((IServiceProvider)s).GetService(typeof(IAsyncResult)));
+            Assert.Null(((IServiceProvider)s).GetService(typeof(IAsyncResult)));
         }
 
         class MySchedulerWithoutServices : LocalScheduler
@@ -940,13 +941,13 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void DetectServices_Null_1()
         {
             var s = new MyDumbScheduler1();
-            Assert.IsNull(Scheduler.AsLongRunning(s));
-            Assert.IsNull(Scheduler.AsPeriodic(s));
-            Assert.IsNull(Scheduler.AsStopwatchProvider(s));
+            Assert.Null(Scheduler.AsLongRunning(s));
+            Assert.Null(Scheduler.AsPeriodic(s));
+            Assert.Null(Scheduler.AsStopwatchProvider(s));
         }
 
         class MyDumbScheduler1 : IScheduler
@@ -972,16 +973,16 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void DetectServices_Null_2()
         {
             var s = new MyDumbScheduler2(new Dictionary<Type, object>());
-            Assert.IsNull(Scheduler.AsLongRunning(s));
-            Assert.IsNull(Scheduler.AsPeriodic(s));
-            Assert.IsNull(Scheduler.AsStopwatchProvider(s));
+            Assert.Null(Scheduler.AsLongRunning(s));
+            Assert.Null(Scheduler.AsPeriodic(s));
+            Assert.Null(Scheduler.AsStopwatchProvider(s));
         }
 
-        [TestMethod]
+        [Fact]
         public void DetectServices_Found()
         {
             {
@@ -992,7 +993,7 @@ namespace ReactiveTests.Tests
                     { typeof(ISchedulerLongRunning), x }
                 });
 
-                Assert.AreEqual(x, Scheduler.AsLongRunning(s));
+                Assert.Equal(x, Scheduler.AsLongRunning(s));
             }
 
             {
@@ -1003,7 +1004,7 @@ namespace ReactiveTests.Tests
                     { typeof(IStopwatchProvider), x }
                 });
 
-                Assert.AreEqual(x, Scheduler.AsStopwatchProvider(s));
+                Assert.Equal(x, Scheduler.AsStopwatchProvider(s));
             }
 
             {
@@ -1014,7 +1015,7 @@ namespace ReactiveTests.Tests
                     { typeof(ISchedulerPeriodic), x }
                 });
 
-                Assert.AreEqual(x, Scheduler.AsPeriodic(s));
+                Assert.Equal(x, Scheduler.AsPeriodic(s));
             }
         }
 
@@ -1085,14 +1086,14 @@ namespace ReactiveTests.Tests
 
 #if HAS_AWAIT
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_Yield_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Yield(default(IScheduler)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Yield(default(IScheduler), CancellationToken.None));
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_Sleep_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Sleep(default(IScheduler), TimeSpan.Zero));
@@ -1102,7 +1103,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Sleep(default(IScheduler), DateTimeOffset.MinValue, CancellationToken.None));
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_ArgumentChecking()
         {
             var tcs = new TaskCompletionSource<IDisposable>();
@@ -1155,7 +1156,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.ScheduleAsync(s, at, d4));
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_Overloads1()
         {
             var tcsI = new TaskCompletionSource<int>();
@@ -1204,7 +1205,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_Overloads2()
         {
             var tcsI = new TaskCompletionSource<int>();
@@ -1253,7 +1254,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_Overloads3()
         {
             var tcsI = new TaskCompletionSource<int>();
@@ -1302,7 +1303,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_NoCancellation1()
         {
             var s = new TestScheduler();
@@ -1336,7 +1337,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_NoCancellation2()
         {
             var s = new TestScheduler();
@@ -1370,7 +1371,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_Awaiters()
         {
             var op = Scheduler.Immediate.Yield();
@@ -1383,7 +1384,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => aw.OnCompleted(() => { }));
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_Yield_Cancel1()
         {
             var cts = new CancellationTokenSource();
@@ -1393,12 +1394,12 @@ namespace ReactiveTests.Tests
 
             cts.Cancel();
 
-            Assert.IsTrue(aw.IsCompleted);
+            Assert.True(aw.IsCompleted);
 
             ReactiveAssert.Throws<OperationCanceledException>(() => aw.GetResult());
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_Yield_Cancel2()
         {
             var cts = new CancellationTokenSource();
@@ -1406,14 +1407,14 @@ namespace ReactiveTests.Tests
             var op = Scheduler.Immediate.Yield(cts.Token);
             var aw = op.GetAwaiter();
 
-            Assert.IsFalse(aw.IsCompleted);
+            Assert.False(aw.IsCompleted);
 
             aw.OnCompleted(() =>
             {
                 //
                 // TODO: Not needed for await pattern, but maybe should be wired up?
                 //
-                // Assert.IsTrue(aw.IsCompleted);
+                // Assert.True(aw.IsCompleted);
 
                 cts.Cancel();
 
@@ -1421,7 +1422,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_Sleep_Cancel()
         {
             var cts = new CancellationTokenSource();
@@ -1429,7 +1430,7 @@ namespace ReactiveTests.Tests
             var op = Scheduler.Default.Sleep(TimeSpan.FromHours(1), cts.Token);
             var aw = op.GetAwaiter();
 
-            Assert.IsFalse(aw.IsCompleted);
+            Assert.False(aw.IsCompleted);
 
             var e = new ManualResetEvent(false);
 
@@ -1447,7 +1448,7 @@ namespace ReactiveTests.Tests
 
 #if !NO_SYNCCTX
 
-        [TestMethod]
+        [Fact]
         public void SchedulerAsync_ScheduleAsync_SyncCtx()
         {
             var old = SynchronizationContext.Current;
@@ -1463,25 +1464,25 @@ namespace ReactiveTests.Tests
 
                 s.ScheduleAsync(async (_, ct) =>
                 {
-                    Assert.AreSame(ctx, SynchronizationContext.Current);
+                    Assert.Same(ctx, SynchronizationContext.Current);
 
                     o.OnNext(42);
 
                     await _.Yield(ct).ConfigureAwait(true);
 
-                    Assert.AreSame(ctx, SynchronizationContext.Current);
+                    Assert.Same(ctx, SynchronizationContext.Current);
 
                     o.OnNext(43);
 
                     await _.Sleep(TimeSpan.FromTicks(10), ct).ConfigureAwait(true);
 
-                    Assert.AreSame(ctx, SynchronizationContext.Current);
+                    Assert.Same(ctx, SynchronizationContext.Current);
 
                     o.OnNext(44);
 
                     await _.Sleep(new DateTimeOffset(250, TimeSpan.Zero), ct).ConfigureAwait(true);
 
-                    Assert.AreSame(ctx, SynchronizationContext.Current);
+                    Assert.Same(ctx, SynchronizationContext.Current);
 
                     o.OnNext(45);
                 });
@@ -1514,3 +1515,4 @@ namespace ReactiveTests.Tests
 #endif
     }
 }
+#endif

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/StopwatchTest.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Reactive.Concurrency;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
@@ -28,13 +28,13 @@ namespace ReactiveTests.Tests
             //    Thread.Sleep(d);
             //    var e2 = sw.Elapsed;
 
-            //    Assert.IsTrue(e2.Ticks > e1.Ticks);
+            //    Assert.True(e2.Ticks > e1.Ticks);
             //    t += (e2 - e1).Ticks;
 
             //    sw.Dispose();
             //}
 
-            //Assert.IsTrue(TimeSpan.FromTicks(t / N).TotalMilliseconds < d * 10 /* 10x margin */);
+            //Assert.True(TimeSpan.FromTicks(t / N).TotalMilliseconds < d * 10 /* 10x margin */);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/SynchronizationContextSchedulerTest.cs

@@ -6,14 +6,14 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class SynchronizationContextSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_ArgumentChecking()
         {
             var ms = new MySync();
@@ -26,17 +26,17 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule<int>(42, TimeSpan.Zero, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_Now()
         {
             var ms = new MySync();
             var s = new SynchronizationContextScheduler(ms);
 
             var res = s.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_ScheduleAction()
         {
             var ms = new MySync();
@@ -44,11 +44,11 @@ namespace ReactiveTests.Tests
 
             var ran = false;
             s.Schedule(() => { ran = true; });
-            Assert.IsTrue(ms.Count == 1);
-            Assert.IsTrue(ran);
+            Assert.True(ms.Count == 1);
+            Assert.True(ran);
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_ScheduleAction_TimeSpan()
         {
             var ms = new MySync();
@@ -58,10 +58,10 @@ namespace ReactiveTests.Tests
             s.Schedule(TimeSpan.FromMilliseconds(1), () => { e.Set(); });
 
             e.WaitOne();
-            Assert.IsTrue(ms.Count == 1);
+            Assert.True(ms.Count == 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_ScheduleAction_DateTimeOffset()
         {
             var ms = new MySync();
@@ -71,10 +71,10 @@ namespace ReactiveTests.Tests
             s.Schedule(DateTimeOffset.Now.AddMilliseconds(100), () => { e.Set(); });
 
             e.WaitOne();
-            Assert.IsTrue(ms.Count >= 1); // Can be > 1 in case of timer queue retry operations.
+            Assert.True(ms.Count >= 1); // Can be > 1 in case of timer queue retry operations.
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_ScheduleActionError()
         {
             var ms = new MySync();
@@ -85,19 +85,18 @@ namespace ReactiveTests.Tests
             try
             {
                 s.Schedule(() => { throw ex; });
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
-                Assert.AreSame(e, ex);
+                Assert.Same(e, ex);
             }
 
-            Assert.IsTrue(ms.Count == 1);
+            Assert.True(ms.Count == 1);
         }
 
 #if !SILVERLIGHT
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip ="Ignored")]        
         public void SynchronizationContext_ScheduleActionDue()
         {
             var ms = new MySync();
@@ -108,8 +107,8 @@ namespace ReactiveTests.Tests
             sw.Start();
             s.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); evt.Set(); });
             evt.WaitOne();
-            Assert.IsTrue(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
-            Assert.IsTrue(ms.Count == 1);
+            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
+            Assert.True(ms.Count == 1);
         }
 #endif
 
@@ -145,7 +144,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_StartedCompleted()
         {
             var ms = new MySync();
@@ -154,12 +153,12 @@ namespace ReactiveTests.Tests
             var started = 0;
             s.Schedule<int>(42, TimeSpan.Zero, (self, x) => { started = ms.Started; return Disposable.Empty; });
 
-            Assert.IsTrue(started == 1);
-            Assert.IsTrue(ms.Count == 1);
-            Assert.IsTrue(ms.Completed == 1);
+            Assert.True(started == 1);
+            Assert.True(ms.Count == 1);
+            Assert.True(ms.Completed == 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_DontPost_Different()
         {
             var ms = new MySync();
@@ -167,11 +166,12 @@ namespace ReactiveTests.Tests
 
             var ran = false;
             s.Schedule(() => { ran = true; });
-            Assert.IsTrue(ms.Count == 1);
-            Assert.IsTrue(ran);
+            Assert.True(ms.Count == 1);
+            Assert.True(ran);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void SynchronizationContext_DontPost_Same()
         {
             var count = 0;
@@ -191,11 +191,12 @@ namespace ReactiveTests.Tests
             t.Start();
             t.Join();
 
-            Assert.IsTrue(count == 0 /* no post */);
-            Assert.IsTrue(ran);
+            Assert.True(count == 0 /* no post */);
+            Assert.True(ran);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void SynchronizationContext_AlwaysPost_Different()
         {
             var ms = new MySync();
@@ -203,11 +204,12 @@ namespace ReactiveTests.Tests
 
             var ran = false;
             s.Schedule(() => { ran = true; });
-            Assert.IsTrue(ms.Count == 1);
-            Assert.IsTrue(ran);
+            Assert.True(ms.Count == 1);
+            Assert.True(ran);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void SynchronizationContext_AlwaysPost_Same()
         {
             var count = 0;
@@ -227,8 +229,9 @@ namespace ReactiveTests.Tests
             t.Start();
             t.Join();
 
-            Assert.IsTrue(count == 1 /* post */);
-            Assert.IsTrue(ran);
+            Assert.True(count == 1 /* post */);
+            Assert.True(ran);
         }
+#endif
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/SynchronizationTest.cs

@@ -4,15 +4,15 @@ using System;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class SynchronizationTests
     {
-        [TestMethod]
+        [Fact]
         public void Synchronization_SubscribeOn_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Synchronization.SubscribeOn(default(IObservable<int>), Scheduler.Immediate));
@@ -24,7 +24,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void Synchronization_ObserveOn_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Synchronization.ObserveOn(default(IObservable<int>), Scheduler.Immediate));
@@ -36,7 +36,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void Synchronization_Synchronize_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Synchronization.Synchronize(default(IObservable<int>)));

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/TaskPoolSchedulerTest.cs

@@ -5,14 +5,14 @@ using System;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class TaskPoolSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void TaskPool_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new TaskPoolScheduler(null));
@@ -23,57 +23,58 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => TaskPoolScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskPool_Now()
         {
             var res = TaskPoolScheduler.Default.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void TaskPool_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = TaskPoolScheduler.Default;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(() => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(() => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskPool_ScheduleActionDueNow()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = TaskPoolScheduler.Default;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(TimeSpan.Zero, () => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.Zero, () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskPool_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = TaskPoolScheduler.Default;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(TimeSpan.FromMilliseconds(1), () => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.FromMilliseconds(1), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskPool_ScheduleActionCancel()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = TaskPoolScheduler.Default;
             var set = false;
-            var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.Fail(); set = true; });
+            var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.True(false); set = true; });
             d.Dispose();
             Thread.Sleep(400);
-            Assert.IsFalse(set);
+            Assert.False(set);
         }
 
 #if !NO_PERF
-        [TestMethod]
+        [Fact]
         public void TaskPool_ScheduleLongRunning()
         {
             var n = 0;
@@ -100,13 +101,14 @@ namespace ReactiveTests.Tests
             d.Dispose();
             e.WaitOne();
 
-            Assert.IsTrue(n >= 0);
+            Assert.True(n >= 0);
         }
 #endif
+#endif
 
 #if !NO_PERF
 #if !NO_STOPWATCH
-        [TestMethod]
+        [Fact]
         public void Stopwatch()
         {
             StopwatchTest.Run(TaskPoolScheduler.Default);
@@ -114,7 +116,7 @@ namespace ReactiveTests.Tests
 #endif
 #endif
 
-        [TestMethod]
+        [Fact]
         public void TaskPool_Periodic()
         {
             var n = 0;
@@ -127,12 +129,13 @@ namespace ReactiveTests.Tests
             });
 
             if (!e.WaitOne(10000))
-                Assert.Fail();
+                Assert.True(false);
 
             d.Dispose();
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void TaskPool_Periodic_NonReentrant()
         {
             var n = 0;
@@ -158,10 +161,11 @@ namespace ReactiveTests.Tests
             Thread.Sleep(500);
             d.Dispose();
 
-            Assert.IsFalse(fail);
+            Assert.False(fail);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void TaskPool_Delay_LargerThanIntMaxValue()
         {
             var dueTime = TimeSpan.FromMilliseconds((double)int.MaxValue + 1);

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/ThreadPoolSchedulerTest.cs

@@ -8,14 +8,14 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ThreadPoolSchedulerTest
     {
-        [TestMethod]
+        [Fact]
         public void Schedule_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule<int>(42, default(Func<IScheduler, int, IDisposable>)));
@@ -23,25 +23,25 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule<int>(42, TimeSpan.Zero, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Get_Now()
         {
             var res = ThreadPoolScheduler.Instance.Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = ThreadPoolScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(() => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(() => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
 #if !NO_CDS
-        [TestMethod]
+        [Fact]
         public void ProperRooting_NoGC_SingleShot()
         {
             var cts = new CancellationTokenSource();
@@ -64,11 +64,11 @@ namespace ReactiveTests.Tests
                 tp.Schedule(TimeSpan.FromMilliseconds(100 + i), () => { cd.Signal(); });
             }
 
-            Assert.IsTrue(cd.Wait(TimeSpan.FromMinutes(1)));
+            Assert.True(cd.Wait(TimeSpan.FromMinutes(1)));
             cts.Cancel();
         }
 
-        [TestMethod]
+        [Fact]
         public void ProperRooting_NoGC_Periodic()
         {
             var cts = new CancellationTokenSource();
@@ -89,7 +89,7 @@ namespace ReactiveTests.Tests
             var n = 0;
             var d = tp.SchedulePeriodic(TimeSpan.FromMilliseconds(80), () => { if (Interlocked.Increment(ref n) == N) e.Set(); });
 
-            Assert.IsTrue(e.WaitOne(TimeSpan.FromMinutes(1)));
+            Assert.True(e.WaitOne(TimeSpan.FromMinutes(1)));
 
             d.Dispose();
 
@@ -98,68 +98,68 @@ namespace ReactiveTests.Tests
 #endif
 
 #if !SILVERLIGHT
-        [TestMethod]
+        [Fact]
         public void ScheduleActionDueRelative()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = ThreadPoolScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleActionDue0()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = ThreadPoolScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(TimeSpan.FromTicks(0), () => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.FromTicks(0), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleActionDueAbsolute()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = ThreadPoolScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.Schedule(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(0.2), () => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(0.2), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void ScheduleActionCancel()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = ThreadPoolScheduler.Instance;
             var set = false;
-            var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.Fail(); set = true; });
+            var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.True(false); set = true; });
             d.Dispose();
             Thread.Sleep(400);
-            Assert.IsFalse(set);
+            Assert.False(set);
         }
 
 #if !NO_PERF
 
-        [TestMethod]
+        [Fact]
         public void ScheduleLongRunning_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.ScheduleLongRunning<int>(42, default(Action<int, ICancelable>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleLongRunning()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = ThreadPoolScheduler.Instance;
             var evt = new ManualResetEvent(false);
-            nt.ScheduleLongRunning(42, (x, cancel) => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.ScheduleLongRunning(42, (x, cancel) => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduleLongRunningCancel()
         {
             var nt = ThreadPoolScheduler.Instance;
@@ -184,12 +184,12 @@ namespace ReactiveTests.Tests
             d.Dispose();
 
             stopped.WaitOne();
-            Assert.IsTrue(n >= 10);
+            Assert.True(n >= 10);
         }
 
 #if !NO_STOPWATCH
 
-        [TestMethod]
+        [Fact]
         public void Stopwatch()
         {
             var nt = ThreadPoolScheduler.Instance;
@@ -200,25 +200,25 @@ namespace ReactiveTests.Tests
             Thread.Sleep(10);
             var s1 = sw.Elapsed.Ticks;
 
-            Assert.IsTrue(s1 > s0);
+            Assert.True(s1 > s0);
         }
 
 #endif
 
-        [TestMethod]
+        [Fact]
         public void Periodic_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.SchedulePeriodic(0, TimeSpan.FromSeconds(1), null));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => ThreadPoolScheduler.Instance.SchedulePeriodic(0, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [TestMethod]
+        [Fact]
         public void Periodic_Regular()
         {
             Periodic_Impl(TimeSpan.FromMilliseconds(25));
         }
 
-        [TestMethod]
+        [Fact]
         public void Periodic_Zero()
         {
             Periodic_Impl(TimeSpan.Zero);
@@ -262,14 +262,14 @@ namespace ReactiveTests.Tests
                     k = n;
             } while (m != k && i++ < 10); // Wait for Dispose to reach the timer; should be almost instantaneous due to nop'ing out of the action.
 
-            Assert.AreNotEqual(10, i);
+            Assert.NotEqual(10, i);
 
             var res = lst.ToArray();
-            Assert.IsTrue(res.Length >= 10);
-            Assert.IsTrue(res.Take(10).SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(res.Length >= 10);
+            Assert.True(res.Take(10).SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Periodic_NonReentrant()
         {
             var n = 0;
@@ -295,13 +295,13 @@ namespace ReactiveTests.Tests
             Thread.Sleep(500);
             d.Dispose();
 
-            Assert.IsFalse(fail);
+            Assert.False(fail);
         }
 
 #endif
 
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void No_ThreadPool_Starvation_Dispose()
         {
             var bwt = default(int);
@@ -324,7 +324,7 @@ namespace ReactiveTests.Tests
             var eio = default(int);
             ThreadPool.GetAvailableThreads(out ewt, out eio);
 
-            Assert.IsFalse(bwt - ewt >= N);
+            Assert.False(bwt - ewt >= N);
         }
 #endif
     }

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/VirtualSchedulerTest.cs

@@ -7,11 +7,11 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class VirtualSchedulerTest
     {
         class VirtualSchedulerTestScheduler : VirtualTimeScheduler<string, char>
@@ -41,25 +41,26 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Virtual_Now()
         {
             var res = new VirtualSchedulerTestScheduler().Now - DateTime.Now;
-            Assert.IsTrue(res.Seconds < 1);
+            Assert.True(res.Seconds < 1);
         }
-
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void Virtual_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
             var scheduler = new VirtualSchedulerTestScheduler();
-            scheduler.Schedule(() => { Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            scheduler.Schedule(() => { Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
             scheduler.Start();
-            Assert.IsTrue(ran);
+            Assert.True(ran);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void Virtual_ScheduleActionError()
         {
             var ex = new Exception();
@@ -69,22 +70,22 @@ namespace ReactiveTests.Tests
                 var scheduler = new VirtualSchedulerTestScheduler();
                 scheduler.Schedule(() => { throw ex; });
                 scheduler.Start();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
-                Assert.AreSame(e, ex);
+                Assert.Same(e, ex);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Virtual_InitialAndComparer_Now()
         {
             var s = new VirtualSchedulerTestScheduler("Bar", Comparer<string>.Default);
-            Assert.AreEqual(3, s.Now.Ticks);
+            Assert.Equal(3, s.Now.Ticks);
         }
 
-        [TestMethod]
+        [Fact]
         public void Virtual_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new VirtualSchedulerTestScheduler("", null));
@@ -100,7 +101,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => VirtualTimeSchedulerExtensions.ScheduleRelative(new VirtualSchedulerTestScheduler(), 'a', default(Action)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Historical_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new HistoricalScheduler(DateTime.Now, default(IComparer<DateTimeOffset>)));
@@ -108,9 +109,8 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new HistoricalScheduler().ScheduleRelative(42, TimeSpan.FromSeconds(1), default(Func<IScheduler, int, IDisposable>)));
         }
 
-#if !SILVERLIGHT
-        [TestMethod]
-        [Ignore]
+#if !SILVERLIGHT && !NO_THREAD
+        [Fact(Skip = "Ignored")]
         public void Virtual_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -118,15 +118,15 @@ namespace ReactiveTests.Tests
             var sw = new Stopwatch();
             sw.Start();
             var scheduler = new VirtualSchedulerTestScheduler();
-            scheduler.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            scheduler.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
             scheduler.Start();
-            Assert.IsTrue(ran, "ran");
-            Assert.IsTrue(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
+            Assert.True(ran, "ran");
+            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 #endif
 
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void Virtual_ThreadSafety()
         {
             for (var i = 0; i < 10; i++)

Rx.NET/Source/Tests.System.Reactive/Tests/ConnectableObservableTest.cs

@@ -5,15 +5,15 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ConnectableObservableTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_Creation()
         {
             var y = 0;
@@ -22,13 +22,13 @@ namespace ReactiveTests.Tests
             var co2 = new ConnectableObservable<int>(Observable.Return<int>(1), s2);
 
             co2.Subscribe(x => y = x);
-            Assert.AreNotEqual(1, y);
+            Assert.NotEqual(1, y);
             
             co2.Connect();
-            Assert.AreEqual(1, y);
+            Assert.Equal(1, y);
         }
 
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_Connected()
         {
             var scheduler = new TestScheduler();
@@ -57,7 +57,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_NotConnected()
         {
             var scheduler = new TestScheduler();
@@ -80,7 +80,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_Disconnected()
         {
             var scheduler = new TestScheduler();
@@ -105,7 +105,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_DisconnectFuture()
         {
             var scheduler = new TestScheduler();
@@ -132,13 +132,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Publish().Subscribe(default(IObserver<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ConnectableObservable_MultipleNonOverlappedConnections()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs

@@ -7,18 +7,17 @@ using System.Reactive.Concurrency;
 using System.Reactive.PlatformServices;
 using System.Runtime.CompilerServices;
 using System.Threading;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     [Serializable]
     public class DefaultConcurrencyAbstractionLayerTest
     {
         private AppDomain _domain;
 
-        [TestInitialize]
-        public void Init()
+        public DefaultConcurrencyAbstractionLayerTest()
         {
             if (_domain == null)
             {
@@ -75,7 +74,7 @@ namespace ReactiveTests.Tests
             _domain.DoCallBack(a);
         }
 
-        [TestMethod]
+        [Fact]
         public void Sleep()
         {
             var ran = new MarshalByRefCell<bool>();
@@ -90,10 +89,10 @@ namespace ReactiveTests.Tests
                 });
             });
 
-            Assert.IsTrue(ran.Value);
+            Assert.True(ran.Value);
         }
 
-        [TestMethod]
+        [Fact]
         public void QueueUserWorkItem()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -111,7 +110,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void StartTimer()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -129,7 +128,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void StartTimer_Cancel()
         {
             Run(StartTimer_Cancel_Callback);
@@ -143,7 +142,7 @@ namespace ReactiveTests.Tests
             }).Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void StartPeriodicTimer()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -165,7 +164,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void StartPeriodicTimer_Cancel()
         {
             Run(StartPeriodicTimer_Cancel_Callback);
@@ -179,7 +178,7 @@ namespace ReactiveTests.Tests
             }).Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void StartPeriodicTimer_Fast()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -201,7 +200,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [TestMethod]
+        [Fact]
         public void StartPeriodicTimer_Fast_Cancel()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -239,16 +238,16 @@ namespace ReactiveTests.Tests
 
             var newValue = (int)_domain.GetData("value");
 
-            Assert.IsTrue(newValue >= value);
+            Assert.True(newValue >= value);
 
             Thread.Sleep(TimeSpan.FromMilliseconds(50));
 
             value = (int)_domain.GetData("value");
 
-            Assert.AreEqual(newValue, value);
+            Assert.Equal(newValue, value);
         }
 
-        [TestMethod]
+        [Fact]
         public void CreateThread()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -318,11 +317,11 @@ namespace ReactiveTests.Tests
             });
 
             e.Value.WaitOne();
-            Assert.IsTrue(string.IsNullOrEmpty(r.Value));
+            Assert.True(string.IsNullOrEmpty(r.Value));
         }
 
 #if !NO_TPL
-        [TestMethod]
+        [Fact]
         public void Cant_Locate_Scheduler()
         {
             if (!Utils.IsRunningWithPortableLibraryBinaries())
@@ -350,12 +349,12 @@ namespace ReactiveTests.Tests
                 }
             });
 
-            Assert.IsTrue(e.Value != null && e.Value is NotSupportedException);
+            Assert.True(e.Value != null && e.Value is NotSupportedException);
         }
 #endif
 
 #if !NO_PERF && !NO_STOPWATCH
-        [TestMethod]
+        [Fact]
         public void Stopwatch()
         {
             var e = new MarshalByRefCell<bool>();
@@ -374,14 +373,14 @@ namespace ReactiveTests.Tests
                 state.Value = snd > fst;
             });
 
-            Assert.IsTrue(e.Value);
+            Assert.True(e.Value);
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void EnsureLoaded()
         {
-            Assert.IsTrue(EnlightenmentProvider.EnsureLoaded());
+            Assert.True(EnlightenmentProvider.EnsureLoaded());
         }
     }
 

Rx.NET/Source/Tests.System.Reactive/Tests/Disposables/DisposableTests.cs

@@ -8,67 +8,67 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class DisposableTests
     {
-        [TestMethod]
+        [Fact]
         public void AnonymousDisposable_Create()
         {
             var d = Disposable.Create(() => { });
-            Assert.IsNotNull(d);
+            Assert.NotNull(d);
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void AnonymousDisposable_CreateNull()
         {
-            Disposable.Create(null);
+            Assert.Throws(typeof(ArgumentNullException), () => Disposable.Create(null));            
         }
 
-        [TestMethod]
+        [Fact]
         public void AnonymousDisposable_Dispose()
         {
             var disposed = false;
             var d = Disposable.Create(() => { disposed = true; });
-            Assert.IsFalse(disposed);
+            Assert.False(disposed);
             d.Dispose();
-            Assert.IsTrue(disposed);
+            Assert.True(disposed);
 
             var c = d as ICancelable;
-            Assert.IsNotNull(c);
-            Assert.IsTrue(c.IsDisposed);
+            Assert.NotNull(c);
+            Assert.True(c.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void EmptyDisposable()
         {
             var d = Disposable.Empty;
-            Assert.IsNotNull(d);
+            Assert.NotNull(d);
             d.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void BooleanDisposable()
         {
             var d = new BooleanDisposable();
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
             d.Dispose();
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(d.IsDisposed);
             d.Dispose();
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(d.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void SingleAssignmentDisposable_SetNull()
         {
             var d = new SingleAssignmentDisposable();
             d.Disposable = null;
         }
 
-        [TestMethod]
+        [Fact]
         public void SingleAssignmentDisposable_DisposeAfterSet()
         {
             var disposed = false;
@@ -77,18 +77,18 @@ namespace ReactiveTests.Tests
             var dd = Disposable.Create(() => { disposed = true; });
             d.Disposable = dd;
 
-            Assert.AreSame(dd, d.Disposable);
+            Assert.Same(dd, d.Disposable);
 
-            Assert.IsFalse(disposed);
+            Assert.False(disposed);
             d.Dispose();
-            Assert.IsTrue(disposed);
+            Assert.True(disposed);
             d.Dispose();
-            Assert.IsTrue(disposed);
+            Assert.True(disposed);
 
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(d.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void SingleAssignmentDisposable_DisposeBeforeSet()
         {
             var disposed = false;
@@ -96,21 +96,21 @@ namespace ReactiveTests.Tests
             var d = new SingleAssignmentDisposable();
             var dd = Disposable.Create(() => { disposed = true; });
 
-            Assert.IsFalse(disposed);
+            Assert.False(disposed);
             d.Dispose();
-            Assert.IsFalse(disposed);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.False(disposed);
+            Assert.True(d.IsDisposed);
 
             d.Disposable = dd;
-            Assert.IsTrue(disposed);
-            //Assert.IsNull(d.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
+            Assert.True(disposed);
+            //Assert.Null(d.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
             d.Disposable.Dispose();        // This should be a nop.
 
             d.Dispose();
-            Assert.IsTrue(disposed);
+            Assert.True(disposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void SingleAssignmentDisposable_SetMultipleTimes()
         {
             var d = new SingleAssignmentDisposable();
@@ -119,7 +119,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => { d.Disposable = Disposable.Empty; });
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable(default(IDisposable[])));
@@ -127,45 +127,45 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new CompositeDisposable(-1));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_Contains()
         {
             var d1 = Disposable.Create(() => {} );
             var d2 = Disposable.Create(() => { });
 
             var g = new CompositeDisposable(d1, d2);
-            Assert.AreEqual(2, g.Count);
-            Assert.IsTrue(g.Contains(d1));
-            Assert.IsTrue(g.Contains(d2));
+            Assert.Equal(2, g.Count);
+            Assert.True(g.Contains(d1));
+            Assert.True(g.Contains(d2));
 
             ReactiveAssert.Throws<ArgumentNullException>(() => g.Contains(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_IsReadOnly()
         {
-            Assert.IsFalse(new CompositeDisposable().IsReadOnly);
+            Assert.False(new CompositeDisposable().IsReadOnly);
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void CompositeDisposable_CopyTo_Null()
         {
-            new CompositeDisposable().CopyTo(null, 0);
+            ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable().CopyTo(null, 0));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
+        [Fact]
         public void CompositeDisposable_CopyTo_Negative()
         {
-            new CompositeDisposable().CopyTo(new IDisposable[2], -1);
+            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new CompositeDisposable().CopyTo(new IDisposable[2], -1));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
+        [Fact]
         public void CompositeDisposable_CopyTo_BeyondEnd()
         {
-            new CompositeDisposable().CopyTo(new IDisposable[2], 2);
+            ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new CompositeDisposable().CopyTo(new IDisposable[2], 2));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_CopyTo()
         {
             var d1 = Disposable.Create(() => { });
@@ -174,22 +174,22 @@ namespace ReactiveTests.Tests
 
             var d = new IDisposable[3];
             g.CopyTo(d, 1);
-            Assert.AreSame(d1, d[1]);
-            Assert.AreSame(d2, d[2]);
+            Assert.Same(d1, d[1]);
+            Assert.Same(d2, d[2]);
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_ToArray()
         {
             var d1 = Disposable.Create(() => { });
             var d2 = Disposable.Create(() => { });
             var g = new CompositeDisposable(d1, d2);
-            Assert.AreEqual(2, g.Count);
+            Assert.Equal(2, g.Count);
             var x = Enumerable.ToArray(g);
-            Assert.IsTrue(g.ToArray().SequenceEqual(new[] { d1, d2 }));
+            Assert.True(g.ToArray().SequenceEqual(new[] { d1, d2 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_GetEnumerator()
         {
             var d1 = Disposable.Create(() => { });
@@ -198,10 +198,10 @@ namespace ReactiveTests.Tests
             var lst = new List<IDisposable>();
             foreach (var x in g)
                 lst.Add(x);
-            Assert.IsTrue(lst.SequenceEqual(new[] { d1, d2 }));
+            Assert.True(lst.SequenceEqual(new[] { d1, d2 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_GetEnumeratorNonGeneric()
         {
             var d1 = Disposable.Create(() => { });
@@ -210,54 +210,54 @@ namespace ReactiveTests.Tests
             var lst = new List<IDisposable>();
             foreach (IDisposable x in (IEnumerable)g)
                 lst.Add(x);
-            Assert.IsTrue(lst.SequenceEqual(new[] { d1, d2 }));
+            Assert.True(lst.SequenceEqual(new[] { d1, d2 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_CollectionInitializer()
         {
             var d1 = Disposable.Create(() => { });
             var d2 = Disposable.Create(() => { });
             var g = new CompositeDisposable { d1, d2 };
-            Assert.AreEqual(2, g.Count);
-            Assert.IsTrue(g.Contains(d1));
-            Assert.IsTrue(g.Contains(d2));
+            Assert.Equal(2, g.Count);
+            Assert.True(g.Contains(d1));
+            Assert.True(g.Contains(d2));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentException))]
+        [Fact]
         public void CompositeDisposable_AddNull_via_params_ctor()
         {
             IDisposable d1 = null;
-            new CompositeDisposable(d1);
+            ReactiveAssert.Throws<ArgumentException>(() => new CompositeDisposable(d1));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentException))]
+        [Fact]
         public void CompositeDisposable_AddNull_via_IEnum_ctor()
         {
             IEnumerable<IDisposable> values = new IDisposable[] { null };
-            new CompositeDisposable(values);
+            ReactiveAssert.Throws<ArgumentException>(() => new CompositeDisposable(values));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void CompositeDisposable_AddNull()
         {
-            new CompositeDisposable().Add(null);
+            ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable().Add(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_Add()
         {
             var d1 = Disposable.Create(() => { });
             var d2 = Disposable.Create(() => { });
             var g = new CompositeDisposable(d1);
-            Assert.AreEqual(1, g.Count);
-            Assert.IsTrue(g.Contains(d1));
+            Assert.Equal(1, g.Count);
+            Assert.True(g.Contains(d1));
             g.Add(d2);
-            Assert.AreEqual(2, g.Count);
-            Assert.IsTrue(g.Contains(d2));
+            Assert.Equal(2, g.Count);
+            Assert.True(g.Contains(d2));
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_AddAfterDispose()
         {
             var disp1 = false;
@@ -266,20 +266,20 @@ namespace ReactiveTests.Tests
             var d1 = Disposable.Create(() => { disp1 = true; });
             var d2 = Disposable.Create(() => { disp2 = true; });
             var g = new CompositeDisposable(d1);
-            Assert.AreEqual(1, g.Count);
+            Assert.Equal(1, g.Count);
 
             g.Dispose();
-            Assert.IsTrue(disp1);
-            Assert.AreEqual(0, g.Count); // CHECK
+            Assert.True(disp1);
+            Assert.Equal(0, g.Count); // CHECK
 
             g.Add(d2);
-            Assert.IsTrue(disp2);
-            Assert.AreEqual(0, g.Count); // CHECK
+            Assert.True(disp2);
+            Assert.Equal(0, g.Count); // CHECK
 
-            Assert.IsTrue(g.IsDisposed);
+            Assert.True(g.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_Remove()
         {
             var disp1 = false;
@@ -289,28 +289,28 @@ namespace ReactiveTests.Tests
             var d2 = Disposable.Create(() => { disp2 = true; });
             var g = new CompositeDisposable(d1, d2);
 
-            Assert.AreEqual(2, g.Count);
-            Assert.IsTrue(g.Contains(d1));
-            Assert.IsTrue(g.Contains(d2));
+            Assert.Equal(2, g.Count);
+            Assert.True(g.Contains(d1));
+            Assert.True(g.Contains(d2));
 
-            Assert.IsTrue(g.Remove(d1));
-            Assert.AreEqual(1, g.Count);
-            Assert.IsFalse(g.Contains(d1));
-            Assert.IsTrue(g.Contains(d2));
-            Assert.IsTrue(disp1);
+            Assert.True(g.Remove(d1));
+            Assert.Equal(1, g.Count);
+            Assert.False(g.Contains(d1));
+            Assert.True(g.Contains(d2));
+            Assert.True(disp1);
 
-            Assert.IsTrue(g.Remove(d2));
-            Assert.IsFalse(g.Contains(d1));
-            Assert.IsFalse(g.Contains(d2));
-            Assert.IsTrue(disp2);
+            Assert.True(g.Remove(d2));
+            Assert.False(g.Contains(d1));
+            Assert.False(g.Contains(d2));
+            Assert.True(disp2);
 
             var disp3 = false;
             var d3 = Disposable.Create(() => { disp3 = true; });
-            Assert.IsFalse(g.Remove(d3));
-            Assert.IsFalse(disp3);
+            Assert.False(g.Remove(d3));
+            Assert.False(disp3);
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_Clear()
         {
             var disp1 = false;
@@ -319,21 +319,21 @@ namespace ReactiveTests.Tests
             var d1 = Disposable.Create(() => { disp1 = true; });
             var d2 = Disposable.Create(() => { disp2 = true; });
             var g = new CompositeDisposable(d1, d2);
-            Assert.AreEqual(2, g.Count);
+            Assert.Equal(2, g.Count);
 
             g.Clear();
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.AreEqual(0, g.Count);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.Equal(0, g.Count);
 
             var disp3 = false;
             var d3 = Disposable.Create(() => { disp3 = true; });
             g.Add(d3);
-            Assert.IsFalse(disp3);
-            Assert.AreEqual(1, g.Count);
+            Assert.False(disp3);
+            Assert.Equal(1, g.Count);
         }
 
-        [TestMethod]
+        [Fact]
         public void CompositeDisposable_RemoveOptimizationBehavior()
         {
             var g = new CompositeDisposable();
@@ -354,87 +354,87 @@ namespace ReactiveTests.Tests
             var d1 = Enumerable.Range(0, N).Where(i => i % 2 == 0).ToArray();
             foreach (var i in d1)
                 g.Remove(m[i]);
-            Assert.IsTrue(r.SequenceEqual(d1));
+            Assert.True(r.SequenceEqual(d1));
 
             var d2 = Enumerable.Range(0, N).Where(i => i % 3 == 0).ToArray();
             foreach (var i in d2)
                 g.Remove(m[i]);
-            Assert.IsTrue(r.SequenceEqual(d1.Concat(d2.Where(x => !d1.Any(y => x == y)))));
+            Assert.True(r.SequenceEqual(d1.Concat(d2.Where(x => !d1.Any(y => x == y)))));
 
             var d3 = Enumerable.Range(0, N).Where(i => i % 5 == 0).ToArray();
             foreach (var i in d3)
                 g.Remove(m[i]);
-            Assert.IsTrue(r.SequenceEqual(d1.Concat(d2.Where(x => !d1.Any(y => x == y))).Concat(d3.Where(x => !d1.Any(y => x == y) && !d2.Any(y => x == y)))));
+            Assert.True(r.SequenceEqual(d1.Concat(d2.Where(x => !d1.Any(y => x == y))).Concat(d3.Where(x => !d1.Any(y => x == y) && !d2.Any(y => x == y)))));
 
             g.Dispose();
 
             var z = r.Except(d1.Union(d2).Union(d3)).ToArray();
-            Assert.IsTrue(z.SequenceEqual(Enumerable.Range(0, N).Where(i => !(i % 2 == 0 || i % 3 == 0 || i % 5 == 0))));
+            Assert.True(z.SequenceEqual(Enumerable.Range(0, N).Where(i => !(i % 2 == 0 || i % 3 == 0 || i % 5 == 0))));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void CompositeDisposable_RemoveNull()
         {
-            new CompositeDisposable().Remove(null);
+            ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable().Remove(null));
         }
 
 #if DESKTOPCLR40 || DESKTOPCLR45 || DESKTOPCLR46
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact, ExpectedException(typeof(ArgumentNullException))]
         public void CancellationDisposable_Ctor_Null()
         {
             new CancellationDisposable(null);
         }
 
-        [TestMethod]
+        [Fact]
         public void CancellationDisposable_DefaultCtor()
         {
             var c = new CancellationDisposable();
-            Assert.IsNotNull(c.Token);
-            Assert.IsFalse(c.Token.IsCancellationRequested);
-            Assert.IsTrue(c.Token.CanBeCanceled);
+            Assert.NotNull(c.Token);
+            Assert.False(c.Token.IsCancellationRequested);
+            Assert.True(c.Token.CanBeCanceled);
             c.Dispose();
-            Assert.IsTrue(c.IsDisposed);
-            Assert.IsTrue(c.Token.IsCancellationRequested);
+            Assert.True(c.IsDisposed);
+            Assert.True(c.Token.IsCancellationRequested);
         }
 
-        [TestMethod]
+        [Fact]
         public void CancellationDisposable_TokenCtor()
         {
             var t = new CancellationTokenSource();
             var c = new CancellationDisposable(t);
-            Assert.IsTrue(t.Token == c.Token);
-            Assert.IsFalse(c.Token.IsCancellationRequested);
-            Assert.IsTrue(c.Token.CanBeCanceled);
+            Assert.True(t.Token == c.Token);
+            Assert.False(c.Token.IsCancellationRequested);
+            Assert.True(c.Token.CanBeCanceled);
             c.Dispose();
-            Assert.IsTrue(c.IsDisposed);
-            Assert.IsTrue(c.Token.IsCancellationRequested);
+            Assert.True(c.IsDisposed);
+            Assert.True(c.Token.IsCancellationRequested);
         }
 #endif
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void ContextDisposable_CreateNullContext()
         {
-            new ContextDisposable(null, Disposable.Empty);
+            ReactiveAssert.Throws<ArgumentNullException>(() => new ContextDisposable(null, Disposable.Empty));
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void ContextDisposable_CreateNullDisposable()
         {
-            new ContextDisposable(new SynchronizationContext(), null);
+            ReactiveAssert.Throws<ArgumentNullException>(() => new ContextDisposable(new SynchronizationContext(), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ContextDisposable()
         {
             var disp = false;
             var m = new MySync();
             var c = new ContextDisposable(m, Disposable.Create(() => { disp = true; }));
-            Assert.AreSame(m, c.Context);
-            Assert.IsFalse(m._disposed);
-            Assert.IsFalse(disp);
+            Assert.Same(m, c.Context);
+            Assert.False(m._disposed);
+            Assert.False(disp);
             c.Dispose();
-            Assert.IsTrue(c.IsDisposed);
-            Assert.IsTrue(m._disposed);
-            Assert.IsTrue(disp);
+            Assert.True(c.IsDisposed);
+            Assert.True(m._disposed);
+            Assert.True(disp);
         }
 
         class MySync : SynchronizationContext
@@ -448,14 +448,14 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void SerialDisposable_Ctor_Prop()
         {
             var m = new SerialDisposable();
-            Assert.IsNull(m.Disposable);
+            Assert.Null(m.Disposable);
         }
 
-        [TestMethod]
+        [Fact]
         public void SerialDisposable_ReplaceBeforeDispose()
         {
             var disp1 = false;
@@ -464,17 +464,17 @@ namespace ReactiveTests.Tests
             var m = new SerialDisposable();
             var d1 = Disposable.Create(() => { disp1 = true; });
             m.Disposable = d1;
-            Assert.AreSame(d1, m.Disposable);
-            Assert.IsFalse(disp1);
+            Assert.Same(d1, m.Disposable);
+            Assert.False(disp1);
 
             var d2 = Disposable.Create(() => { disp2 = true; });
             m.Disposable = d2;
-            Assert.AreSame(d2, m.Disposable);
-            Assert.IsTrue(disp1);
-            Assert.IsFalse(disp2);
+            Assert.Same(d2, m.Disposable);
+            Assert.True(disp1);
+            Assert.False(disp2);
         }
 
-        [TestMethod]
+        [Fact]
         public void SerialDisposable_ReplaceAfterDispose()
         {
             var disp1 = false;
@@ -482,20 +482,20 @@ namespace ReactiveTests.Tests
 
             var m = new SerialDisposable();
             m.Dispose();
-            Assert.IsTrue(m.IsDisposed);
+            Assert.True(m.IsDisposed);
 
             var d1 = Disposable.Create(() => { disp1 = true; });
             m.Disposable = d1;
-            Assert.IsNull(m.Disposable); // CHECK
-            Assert.IsTrue(disp1);
+            Assert.Null(m.Disposable); // CHECK
+            Assert.True(disp1);
 
             var d2 = Disposable.Create(() => { disp2 = true; });
             m.Disposable = d2;
-            Assert.IsNull(m.Disposable); // CHECK
-            Assert.IsTrue(disp2);
+            Assert.Null(m.Disposable); // CHECK
+            Assert.True(disp2);
         }
 
-        [TestMethod]
+        [Fact]
         public void SerialDisposable_Dispose()
         {
             var disp = false;
@@ -503,108 +503,108 @@ namespace ReactiveTests.Tests
             var m = new SerialDisposable();
             var d = Disposable.Create(() => { disp = true; });
             m.Disposable = d;
-            Assert.AreSame(d, m.Disposable);
-            Assert.IsFalse(disp);
+            Assert.Same(d, m.Disposable);
+            Assert.False(disp);
 
             m.Dispose();
-            Assert.IsTrue(m.IsDisposed);
-            Assert.IsTrue(disp);
-            //Assert.IsNull(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
+            Assert.True(m.IsDisposed);
+            Assert.True(disp);
+            //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void RefCountDisposable_Ctor_Null()
         {
-            new RefCountDisposable(null);
+            ReactiveAssert.Throws<ArgumentNullException>(() => new RefCountDisposable(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCountDisposable_SingleReference()
         {
             var d = new BooleanDisposable();
             var r = new RefCountDisposable(d);
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
             r.Dispose();
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(d.IsDisposed);
             r.Dispose();
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(d.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCountDisposable_RefCounting()
         {
             var d = new BooleanDisposable();
             var r = new RefCountDisposable(d);
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             var d1 = r.GetDisposable();
             var d2 = r.GetDisposable();
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             d1.Dispose();
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             d2.Dispose();
-            Assert.IsFalse(d.IsDisposed); // CHECK
+            Assert.False(d.IsDisposed); // CHECK
 
             r.Dispose();
-            Assert.IsTrue(d.IsDisposed);
-            Assert.IsTrue(r.IsDisposed);
+            Assert.True(d.IsDisposed);
+            Assert.True(r.IsDisposed);
 
             var d3 = r.GetDisposable(); // CHECK
             d3.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCountDisposable_PrimaryDisposesFirst()
         {
             var d = new BooleanDisposable();
             var r = new RefCountDisposable(d);
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             var d1 = r.GetDisposable();
             var d2 = r.GetDisposable();
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             d1.Dispose();
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             r.Dispose();
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
             d2.Dispose();
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(d.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduledDisposable_Null()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledDisposable(null, Disposable.Empty));
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledDisposable(Scheduler.Immediate, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ScheduledDisposable()
         {
             var d = new BooleanDisposable();
             var s = new ScheduledDisposable(Scheduler.Immediate, d);
 
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(d.IsDisposed);
 
-            Assert.AreSame(Scheduler.Immediate, s.Scheduler);
-            Assert.AreSame(d, s.Disposable);
+            Assert.Same(Scheduler.Immediate, s.Scheduler);
+            Assert.Same(d, s.Disposable);
 
             s.Dispose();
 
-            Assert.IsTrue(d.IsDisposed);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.True(d.IsDisposed);
+            Assert.True(s.IsDisposed);
 
-            Assert.AreSame(Scheduler.Immediate, s.Scheduler);
-            //Assert.AreSame(d, s.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
+            Assert.Same(Scheduler.Immediate, s.Scheduler);
+            //Assert.Same(d, s.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
             s.Disposable.Dispose();            // This should be a nop.
         }
 
-        [TestMethod]
+        [Fact]
         public void MultipleAssignmentDisposable()
         {
             var m = new MultipleAssignmentDisposable();
@@ -612,32 +612,32 @@ namespace ReactiveTests.Tests
             var disp1 = false;
             var d1 = Disposable.Create(() => { disp1 = true; });
             m.Disposable = d1;
-            Assert.AreSame(d1, m.Disposable);
-            Assert.IsFalse(m.IsDisposed);
+            Assert.Same(d1, m.Disposable);
+            Assert.False(m.IsDisposed);
 
             var disp2 = false;
             var d2 = Disposable.Create(() => { disp2 = true; });
             m.Disposable = d2;
-            Assert.AreSame(d2, m.Disposable);
-            Assert.IsFalse(m.IsDisposed);
-            Assert.IsFalse(disp1);
+            Assert.Same(d2, m.Disposable);
+            Assert.False(m.IsDisposed);
+            Assert.False(disp1);
 
             m.Dispose();
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(m.IsDisposed);
-            //Assert.IsNull(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
+            Assert.True(disp2);
+            Assert.True(m.IsDisposed);
+            //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
             m.Disposable.Dispose();        // This should be a nop.
 
             var disp3 = false;
             var d3 = Disposable.Create(() => { disp3 = true; });
             m.Disposable = d3;
-            Assert.IsTrue(disp3);
-            //Assert.IsNull(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
+            Assert.True(disp3);
+            //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
             m.Disposable.Dispose();        // This should be a nop.
-            Assert.IsTrue(m.IsDisposed);
+            Assert.True(m.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void StableCompositeDisposable_ArgumentChecking()
         {
             var d = Disposable.Empty;
@@ -653,100 +653,100 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentException>(() => StableCompositeDisposable.Create(d, d, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void StableCompositeDisposable_Binary()
         {
             var disp1 = false;
-            var d1 = Disposable.Create(() => { Assert.IsFalse(disp1); disp1 = true; });
+            var d1 = Disposable.Create(() => { Assert.False(disp1); disp1 = true; });
 
             var disp2 = false;
-            var d2 = Disposable.Create(() => { Assert.IsFalse(disp2); disp2 = true; });
+            var d2 = Disposable.Create(() => { Assert.False(disp2); disp2 = true; });
 
             var d = StableCompositeDisposable.Create(d1, d2);
 
-            Assert.IsFalse(disp1);
-            Assert.IsFalse(disp2);
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(disp1);
+            Assert.False(disp2);
+            Assert.False(d.IsDisposed);
 
             d.Dispose();
 
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.True(d.IsDisposed);
 
             d.Dispose();
 
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.True(d.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void StableCompositeDisposable_Nary1()
         {
             var disp1 = false;
-            var d1 = Disposable.Create(() => { Assert.IsFalse(disp1); disp1 = true; });
+            var d1 = Disposable.Create(() => { Assert.False(disp1); disp1 = true; });
 
             var disp2 = false;
-            var d2 = Disposable.Create(() => { Assert.IsFalse(disp2); disp2 = true; });
+            var d2 = Disposable.Create(() => { Assert.False(disp2); disp2 = true; });
 
             var disp3 = false;
-            var d3 = Disposable.Create(() => { Assert.IsFalse(disp3); disp3 = true; });
+            var d3 = Disposable.Create(() => { Assert.False(disp3); disp3 = true; });
 
             var d = StableCompositeDisposable.Create(d1, d2, d3);
 
-            Assert.IsFalse(disp1);
-            Assert.IsFalse(disp2);
-            Assert.IsFalse(disp3);
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(disp1);
+            Assert.False(disp2);
+            Assert.False(disp3);
+            Assert.False(d.IsDisposed);
 
             d.Dispose();
 
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(disp3);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.True(disp3);
+            Assert.True(d.IsDisposed);
 
             d.Dispose();
 
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(disp3);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.True(disp3);
+            Assert.True(d.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void StableCompositeDisposable_Nary2()
         {
             var disp1 = false;
-            var d1 = Disposable.Create(() => { Assert.IsFalse(disp1); disp1 = true; });
+            var d1 = Disposable.Create(() => { Assert.False(disp1); disp1 = true; });
 
             var disp2 = false;
-            var d2 = Disposable.Create(() => { Assert.IsFalse(disp2); disp2 = true; });
+            var d2 = Disposable.Create(() => { Assert.False(disp2); disp2 = true; });
 
             var disp3 = false;
-            var d3 = Disposable.Create(() => { Assert.IsFalse(disp3); disp3 = true; });
+            var d3 = Disposable.Create(() => { Assert.False(disp3); disp3 = true; });
 
             var d = StableCompositeDisposable.Create(new List<IDisposable>(new[] { d1, d2, d3 }));
 
-            Assert.IsFalse(disp1);
-            Assert.IsFalse(disp2);
-            Assert.IsFalse(disp3);
-            Assert.IsFalse(d.IsDisposed);
+            Assert.False(disp1);
+            Assert.False(disp2);
+            Assert.False(disp3);
+            Assert.False(d.IsDisposed);
 
             d.Dispose();
 
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(disp3);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.True(disp3);
+            Assert.True(d.IsDisposed);
 
             d.Dispose();
 
-            Assert.IsTrue(disp1);
-            Assert.IsTrue(disp2);
-            Assert.IsTrue(disp3);
-            Assert.IsTrue(d.IsDisposed);
+            Assert.True(disp1);
+            Assert.True(disp2);
+            Assert.True(disp3);
+            Assert.True(d.IsDisposed);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/EventPatternSourceBaseTest.cs

@@ -4,14 +4,14 @@ using System;
 using System.Reactive;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class EventPatternSourceBaseTest
     {
-        [TestMethod]
+        [Fact]
         public void ArgumentChecking()
         {
             var xs = Observable.Empty<EventPattern<object, EventArgs>>();

Rx.NET/Source/Tests.System.Reactive/Tests/ImmutableListTest.cs

@@ -1,65 +1,65 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Linq;
 using System.Reactive;
 
 namespace ReactiveTests.Tests
 {
 #if !SIGNED
-    [TestClass]
+    
     public class ImmutableListTest
     {
-        [TestMethod]
+        [Fact]
         public void ImmutableList_Basics()
         {
             var list = ImmutableList<int>.Empty;
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { }));
+            Assert.True(list.Data.SequenceEqual(new int[] { }));
 
             list = list.Add(42);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { 42 }));
+            Assert.True(list.Data.SequenceEqual(new int[] { 42 }));
 
             list = list.Remove(42);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { }));
+            Assert.True(list.Data.SequenceEqual(new int[] { }));
 
             list = list.Remove(42);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { }));
+            Assert.True(list.Data.SequenceEqual(new int[] { }));
 
             list = list.Add(43);
             list = list.Add(44);
             list = list.Add(43);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { 43, 44, 43 }));
+            Assert.True(list.Data.SequenceEqual(new int[] { 43, 44, 43 }));
 
             list = list.Remove(43);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { 44, 43 }));
+            Assert.True(list.Data.SequenceEqual(new int[] { 44, 43 }));
 
             list = list.Remove(43);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { 44 }));
+            Assert.True(list.Data.SequenceEqual(new int[] { 44 }));
 
             list = list.Remove(44);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new int[] { }));
+            Assert.True(list.Data.SequenceEqual(new int[] { }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ImmutableList_Nulls()
         {
             var list = ImmutableList<string>.Empty;
 
-            Assert.IsTrue(list.Data.SequenceEqual(new string[] { }));
+            Assert.True(list.Data.SequenceEqual(new string[] { }));
 
             list = list.Add(null);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new string[] { null }));
+            Assert.True(list.Data.SequenceEqual(new string[] { null }));
 
             list = list.Remove(null);
 
-            Assert.IsTrue(list.Data.SequenceEqual(new string[] { }));
+            Assert.True(list.Data.SequenceEqual(new string[] { }));
         }
         }
 #endif

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableAwaiterTest.cs

@@ -10,16 +10,16 @@ using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 using System.Reactive.Disposables;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ObservableAwaiterTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Await_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter<int>(default(IObservable<int>)));
@@ -28,7 +28,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter(Observable.Empty<int>()).OnCompleted(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Await()
         {
             var scheduler = new TestScheduler();
@@ -51,15 +51,15 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(410, t);
-            Assert.AreEqual(3, result);
+            Assert.Equal(410, t);
+            Assert.Equal(3, result);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(100)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Await_Connectable()
         {
             var scheduler = new TestScheduler();
@@ -87,12 +87,12 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(100, s);
-            Assert.AreEqual(260, t);
-            Assert.AreEqual(42, result);
+            Assert.Equal(100, s);
+            Assert.Equal(260, t);
+            Assert.Equal(42, result);
         }
 
-        [TestMethod]
+        [Fact]
         public void Await_Error()
         {
             var scheduler = new TestScheduler();
@@ -116,14 +116,14 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(410, t);
+            Assert.Equal(410, t);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(100)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Await_Never()
         {
             var scheduler = new TestScheduler();
@@ -145,15 +145,15 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(long.MaxValue, t);
-            Assert.IsFalse(hasValue);
+            Assert.Equal(long.MaxValue, t);
+            Assert.False(hasValue);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(100)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Await_Empty()
         {
             var scheduler = new TestScheduler();
@@ -170,14 +170,14 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(300, t);
+            Assert.Equal(300, t);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(100)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_ArgumentChecking()
         {
             var ct = CancellationToken.None;
@@ -186,7 +186,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.RunAsync<int>(default(IConnectableObservable<int>), ct));
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_Simple()
         {
             var scheduler = new TestScheduler();
@@ -205,15 +205,15 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(250, t);
-            Assert.AreEqual(42, result);
+            Assert.Equal(250, t);
+            Assert.Equal(42, result);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(100)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_Cancelled()
         {
             var cts = new CancellationTokenSource();
@@ -243,13 +243,13 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(200, t);
+            Assert.Equal(200, t);
 
             xs.Subscriptions.AssertEqual(
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_Cancel()
         {
             var cts = new CancellationTokenSource();
@@ -279,14 +279,14 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(210, t);
+            Assert.Equal(210, t);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(100, 210)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_Connectable()
         {
             var scheduler = new TestScheduler();
@@ -314,12 +314,12 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(100, s);
-            Assert.AreEqual(260, t);
-            Assert.AreEqual(42, result);
+            Assert.Equal(100, s);
+            Assert.Equal(260, t);
+            Assert.Equal(42, result);
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_Connectable_Cancelled()
         {
             var cts = new CancellationTokenSource();
@@ -358,11 +358,11 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.IsFalse(s.HasValue);
-            Assert.AreEqual(200, t);
+            Assert.False(s.HasValue);
+            Assert.Equal(200, t);
         }
 
-        [TestMethod]
+        [Fact]
         public void RunAsync_Connectable_Cancel()
         {
             var cts = new CancellationTokenSource();
@@ -403,9 +403,9 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(100, s);
-            Assert.AreEqual(210, d);
-            Assert.AreEqual(210, t);
+            Assert.Equal(100, s);
+            Assert.Equal(210, d);
+            Assert.Equal(210, t);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableBindingTest.cs

@@ -7,17 +7,17 @@ using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableBindingTest : ReactiveTest
     {
         #region Multicast
 
-        [TestMethod]
+        [Fact]
         public void Multicast_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int>(null, new Subject<int>()));
@@ -27,7 +27,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Multicast<int, int, int>(DummyObservable<int>.Instance, () => new Subject<int>(), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Hot_1()
         {
             var scheduler = new TestScheduler();
@@ -69,7 +69,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Hot_2()
         {
             var scheduler = new TestScheduler();
@@ -111,7 +111,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Hot_3()
         {
             var scheduler = new TestScheduler();
@@ -157,7 +157,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Hot_4()
         {
             var scheduler = new TestScheduler();
@@ -205,7 +205,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Hot_5()
         {
             var scheduler = new TestScheduler();
@@ -246,7 +246,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Hot_6()
         {
             var scheduler = new TestScheduler();
@@ -285,7 +285,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Cold_Completed()
         {
             var scheduler = new TestScheduler();
@@ -320,7 +320,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Cold_Error()
         {
             var scheduler = new TestScheduler();
@@ -357,7 +357,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Cold_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -390,7 +390,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_Cold_Zip()
         {
             var scheduler = new TestScheduler();
@@ -425,7 +425,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_SubjectSelectorThrows()
         {
             var ex = new Exception();
@@ -450,7 +450,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Multicast_SelectorThrows()
         {
             var ex = new Exception();
@@ -479,7 +479,7 @@ namespace ReactiveTests.Tests
 
         #region Publish
 
-        [TestMethod]
+        [Fact]
         public void Publish_Cold_Zip()
         {
             var scheduler = new TestScheduler();
@@ -514,7 +514,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -524,7 +524,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Publish<int, int>(someObservable, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_Basic()
         {
             var scheduler = new TestScheduler();
@@ -581,7 +581,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_Error()
         {
             var scheduler = new TestScheduler();
@@ -638,7 +638,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_Complete()
         {
             var scheduler = new TestScheduler();
@@ -693,7 +693,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -746,7 +746,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Publish_MultipleConnections()
         {
             var xs = Observable.Never<int>();
@@ -755,19 +755,19 @@ namespace ReactiveTests.Tests
             var connection1 = ys.Connect();
             var connection2 = ys.Connect();
 
-            Assert.AreSame(connection1, connection2);
+            Assert.Same(connection1, connection2);
 
             connection1.Dispose();
             connection2.Dispose();
 
             var connection3 = ys.Connect();
 
-            Assert.AreNotSame(connection1, connection3);
+            Assert.NotSame(connection1, connection3);
 
             connection3.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLambda_Zip_Complete()
         {
             var scheduler = new TestScheduler();
@@ -813,7 +813,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLambda_Zip_Error()
         {
             var scheduler = new TestScheduler();
@@ -861,7 +861,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLambda_Zip_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -905,7 +905,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -915,7 +915,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Publish(someObservable, default(Func<IObservable<int>, IObservable<int>>), 1));
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_SanityCheck()
         {
             var someObservable = Observable.Empty<int>();
@@ -923,7 +923,7 @@ namespace ReactiveTests.Tests
             Observable.Publish(Observable.Range(1, 10), x => x, 0).AssertEqual(Observable.Range(0, 11));
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_Basic()
         {
             var scheduler = new TestScheduler();
@@ -981,7 +981,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_Error()
         {
             var scheduler = new TestScheduler();
@@ -1039,7 +1039,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_Complete()
         {
             var scheduler = new TestScheduler();
@@ -1095,7 +1095,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1149,7 +1149,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValue_MultipleConnections()
         {
             var xs = Observable.Never<int>();
@@ -1158,19 +1158,19 @@ namespace ReactiveTests.Tests
             var connection1 = ys.Connect();
             var connection2 = ys.Connect();
 
-            Assert.AreSame(connection1, connection2);
+            Assert.Same(connection1, connection2);
 
             connection1.Dispose();
             connection2.Dispose();
 
             var connection3 = ys.Connect();
 
-            Assert.AreNotSame(connection1, connection3);
+            Assert.NotSame(connection1, connection3);
 
             connection3.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValueLambda_Zip_Complete()
         {
             var scheduler = new TestScheduler();
@@ -1217,7 +1217,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValueLambda_Zip_Error()
         {
             var scheduler = new TestScheduler();
@@ -1266,7 +1266,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishWithInitialValueLambda_Zip_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1315,7 +1315,7 @@ namespace ReactiveTests.Tests
 
         #region PublishLast
 
-        [TestMethod]
+        [Fact]
         public void PublishLast_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -1326,7 +1326,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.PublishLast<int, int>(someObservable, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLast_Basic()
         {
             var scheduler = new TestScheduler();
@@ -1378,7 +1378,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLast_Error()
         {
             var scheduler = new TestScheduler();
@@ -1429,7 +1429,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLast_Complete()
         {
             var scheduler = new TestScheduler();
@@ -1479,7 +1479,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLast_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1531,7 +1531,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLast_MultipleConnections()
         {
             var xs = Observable.Never<int>();
@@ -1540,19 +1540,19 @@ namespace ReactiveTests.Tests
             var connection1 = ys.Connect();
             var connection2 = ys.Connect();
 
-            Assert.AreSame(connection1, connection2);
+            Assert.Same(connection1, connection2);
 
             connection1.Dispose();
             connection2.Dispose();
 
             var connection3 = ys.Connect();
 
-            Assert.AreNotSame(connection1, connection3);
+            Assert.NotSame(connection1, connection3);
 
             connection3.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLastLambda_Zip_Complete()
         {
             var scheduler = new TestScheduler();
@@ -1588,7 +1588,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLastLambda_Zip_Error()
         {
             var scheduler = new TestScheduler();
@@ -1625,7 +1625,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PublishLastLambda_Zip_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1664,13 +1664,13 @@ namespace ReactiveTests.Tests
 
         #region RefCount
 
-        [TestMethod]
+        [Fact]
         public void RefCount_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.RefCount<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCount_ConnectsOnFirst()
         {
             var scheduler = new TestScheduler();
@@ -1699,10 +1699,10 @@ namespace ReactiveTests.Tests
                 OnCompleted<int>(250)
             );
 
-            Assert.IsTrue(subject.Disposed);
+            Assert.True(subject.Disposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCount_NotConnected()
         {
             var disconnected = false;
@@ -1722,31 +1722,31 @@ namespace ReactiveTests.Tests
             var refd = conn.RefCount();
 
             var dis1 = refd.Subscribe();
-            Assert.AreEqual(1, count);
-            Assert.AreEqual(1, subject.SubscribeCount);
-            Assert.IsFalse(disconnected);
+            Assert.Equal(1, count);
+            Assert.Equal(1, subject.SubscribeCount);
+            Assert.False(disconnected);
 
             var dis2 = refd.Subscribe();
-            Assert.AreEqual(1, count);
-            Assert.AreEqual(2, subject.SubscribeCount);
-            Assert.IsFalse(disconnected);
+            Assert.Equal(1, count);
+            Assert.Equal(2, subject.SubscribeCount);
+            Assert.False(disconnected);
 
             dis1.Dispose();
-            Assert.IsFalse(disconnected);
+            Assert.False(disconnected);
             dis2.Dispose();
-            Assert.IsTrue(disconnected);
+            Assert.True(disconnected);
             disconnected = false;
 
             var dis3 = refd.Subscribe();
-            Assert.AreEqual(2, count);
-            Assert.AreEqual(3, subject.SubscribeCount);
-            Assert.IsFalse(disconnected);
+            Assert.Equal(2, count);
+            Assert.Equal(3, subject.SubscribeCount);
+            Assert.False(disconnected);
 
             dis3.Dispose();
-            Assert.IsTrue(disconnected);
+            Assert.True(disconnected);
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCount_OnError()
         {
             var ex = new Exception();
@@ -1754,11 +1754,11 @@ namespace ReactiveTests.Tests
 
             var res = xs.Publish().RefCount();
 
-            res.Subscribe(_ => { Assert.Fail(); }, ex_ => { Assert.AreSame(ex, ex_); }, () => { Assert.Fail(); });
-            res.Subscribe(_ => { Assert.Fail(); }, ex_ => { Assert.AreSame(ex, ex_); }, () => { Assert.Fail(); });
+            res.Subscribe(_ => { Assert.True(false); }, ex_ => { Assert.Same(ex, ex_); }, () => { Assert.True(false); });
+            res.Subscribe(_ => { Assert.True(false); }, ex_ => { Assert.Same(ex, ex_); }, () => { Assert.True(false); });
         }
 
-        [TestMethod]
+        [Fact]
         public void RefCount_Publish()
         {
             var scheduler = new TestScheduler();
@@ -1832,7 +1832,7 @@ namespace ReactiveTests.Tests
 
         #region Replay
 
-        [TestMethod]
+        [Fact]
         public void Replay_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -1888,7 +1888,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Replay(someObservable, x => x, 1, TimeSpan.FromSeconds(1), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCount_Basic()
         {
             var scheduler = new TestScheduler();
@@ -1944,7 +1944,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCount_Error()
         {
             var scheduler = new TestScheduler();
@@ -2000,7 +2000,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCount_Complete()
         {
             var scheduler = new TestScheduler();
@@ -2054,7 +2054,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCount_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -2109,7 +2109,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCount_MultipleConnections()
         {
             var xs = Observable.Never<int>();
@@ -2118,19 +2118,19 @@ namespace ReactiveTests.Tests
             var connection1 = ys.Connect();
             var connection2 = ys.Connect();
 
-            Assert.AreSame(connection1, connection2);
+            Assert.Same(connection1, connection2);
 
             connection1.Dispose();
             connection2.Dispose();
 
             var connection3 = ys.Connect();
 
-            Assert.AreNotSame(connection1, connection3);
+            Assert.NotSame(connection1, connection3);
 
             connection3.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCountLambda_Zip_Complete()
         {
             var scheduler = new TestScheduler();
@@ -2192,7 +2192,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCountLambda_Zip_Error()
         {
             var scheduler = new TestScheduler();
@@ -2250,7 +2250,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayCountLambda_Zip_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -2301,7 +2301,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTime_Basic()
         {
             var scheduler = new TestScheduler();
@@ -2358,7 +2358,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTime_Error()
         {
             var scheduler = new TestScheduler();
@@ -2412,7 +2412,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTime_Complete()
         {
             var scheduler = new TestScheduler();
@@ -2465,7 +2465,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTime_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -2520,7 +2520,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTime_MultipleConnections()
         {
             var xs = Observable.Never<int>();
@@ -2529,19 +2529,19 @@ namespace ReactiveTests.Tests
             var connection1 = ys.Connect();
             var connection2 = ys.Connect();
 
-            Assert.AreSame(connection1, connection2);
+            Assert.Same(connection1, connection2);
 
             connection1.Dispose();
             connection2.Dispose();
 
             var connection3 = ys.Connect();
 
-            Assert.AreNotSame(connection1, connection3);
+            Assert.NotSame(connection1, connection3);
 
             connection3.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTimeLambda_Zip_Complete()
         {
             var scheduler = new TestScheduler();
@@ -2600,7 +2600,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTimeLambda_Zip_Error()
         {
             var scheduler = new TestScheduler();
@@ -2657,7 +2657,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayTimeLambda_Zip_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -2708,7 +2708,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Replay_Default1()
         {
             var s = new Subject<int>();
@@ -2725,7 +2725,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void Replay_Default2()
         {
             var s = new Subject<int>();
@@ -2742,7 +2742,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void Replay_Default3()
         {
             var s = new Subject<int>();
@@ -2759,7 +2759,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void Replay_Default4()
         {
             var s = new Subject<int>();
@@ -2776,7 +2776,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayLambda_Default1()
         {
             var xs = Observable.Range(1, 10).Replay(_xs => _xs, 100, DefaultScheduler.Instance);
@@ -2785,7 +2785,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayLambda_Default2()
         {
             var xs = Observable.Range(1, 10).Replay(_xs => _xs, TimeSpan.FromHours(1), DefaultScheduler.Instance);
@@ -2794,7 +2794,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayLambda_Default3()
         {
             var xs = Observable.Range(1, 10).Replay(_xs => _xs, 100, TimeSpan.FromHours(1), DefaultScheduler.Instance);
@@ -2803,7 +2803,7 @@ namespace ReactiveTests.Tests
             xs.AssertEqual(ys);
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplayLambda_Default4()
         {
             var xs = Observable.Range(1, 10).Replay(_xs => _xs, DefaultScheduler.Instance);

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableConcurrencyTest.cs

@@ -9,9 +9,11 @@ using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Threading;
+#if NET45
 using System.Windows.Threading;
+#endif
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 #if HAS_WINFORMS
@@ -24,12 +26,12 @@ using Microsoft.Silverlight.Testing;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableConcurrencyTest : TestBase
     {
-        #region + ObserveOn +
+#region + ObserveOn +
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -42,6 +44,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ControlObservable.ObserveOn<int>(someObservable, default(Label)));
 #endif
 
+#if HAS_DISPATCHER
 #if USE_SL_DISPATCHER
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn<int>(default(IObservable<int>), new DispatcherScheduler(System.Windows.Deployment.Current.Dispatcher)));
 #else
@@ -55,15 +58,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.ObserveOn<int>(default(IObservable<int>), Dispatcher.CurrentDispatcher));
 #endif
             ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.ObserveOn<int>(someObservable, default(Dispatcher)));
-
+            ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.ObserveOnDispatcher<int>(default(IObservable<int>)));
+#endif
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn<int>(default(IObservable<int>), new SynchronizationContext()));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn<int>(someObservable, default(SynchronizationContext)));
-
-            ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.ObserveOnDispatcher<int>(default(IObservable<int>)));
         }
 
 #if HAS_WINFORMS
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Control()
         {
             var lbl = CreateLabel();
@@ -78,10 +80,10 @@ namespace ReactiveTests.Tests
 
             evt.WaitOne();
             Application.Exit();
-            Assert.IsTrue(okay);
+            Assert.True(okay);
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_ControlScheduler()
         {
             var lbl = CreateLabel();
@@ -96,7 +98,7 @@ namespace ReactiveTests.Tests
 
             evt.WaitOne();
             Application.Exit();
-            Assert.IsTrue(okay);
+            Assert.True(okay);
         }
 
         private Label CreateLabel()
@@ -121,8 +123,8 @@ namespace ReactiveTests.Tests
             return lbl;
         }
 #endif
-
-        [TestMethod]
+#if HAS_DISPATCHER
+        [Fact]
         [Asynchronous]
         public void ObserveOn_Dispatcher()
         {
@@ -136,14 +138,14 @@ namespace ReactiveTests.Tests
                     okay &= (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext);
                 }, () =>
                 {
-                    Assert.IsTrue(okay);
+                    Assert.True(okay);
                     dispatcher.InvokeShutdown();
                     evt.Set();
                 });
             });
         }
 
-        [TestMethod]
+        [Fact]
         [Asynchronous]
         public void ObserveOn_DispatcherScheduler()
         {
@@ -157,14 +159,14 @@ namespace ReactiveTests.Tests
                     okay &= (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext);
                 }, () =>
                 {
-                    Assert.IsTrue(okay);
+                    Assert.True(okay);
                     dispatcher.InvokeShutdown();
                     evt.Set();
                 });
             });
         }
 
-        [TestMethod]
+        [Fact]
         [Asynchronous]
         public void ObserveOn_CurrentDispatcher()
         {
@@ -180,7 +182,7 @@ namespace ReactiveTests.Tests
                         okay &= (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext);
                     },  () =>
                     {
-                        Assert.IsTrue(okay);
+                        Assert.True(okay);
                         dispatcher.InvokeShutdown();
                         evt.Set();
                     });
@@ -188,7 +190,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         [Asynchronous]
         public void ObserveOn_Error()
         {
@@ -207,26 +209,26 @@ namespace ReactiveTests.Tests
                     },
                     e =>
                     {
-                        Assert.IsTrue(okay);
-                        Assert.AreSame(ex, e);
+                        Assert.True(okay);
+                        Assert.Same(ex, e);
                         dispatcher.InvokeShutdown();
                         evt.Set();
                     },
                     () =>
                     {
-                        Assert.Fail();
+                        Assert.True(false);
                         dispatcher.InvokeShutdown();
                         evt.Set();
                     });
                 }));
             });
         }
+#endif
+#endregion
 
-        #endregion
-
-        #region SubscribeOn
+#region SubscribeOn
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -238,7 +240,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ControlObservable.SubscribeOn<int>(default(IObservable<int>), new Label()));
             ReactiveAssert.Throws<ArgumentNullException>(() => ControlObservable.SubscribeOn<int>(someObservable, default(Label)));
 #endif
-
+#if HAS_DISPATCHER
 #if USE_SL_DISPATCHER
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn<int>(default(IObservable<int>), new DispatcherScheduler(System.Windows.Deployment.Current.Dispatcher)));
 #else
@@ -252,15 +254,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.SubscribeOn<int>(default(IObservable<int>), Dispatcher.CurrentDispatcher));
 #endif
             ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.SubscribeOn<int>(someObservable, default(Dispatcher)));
-
+            ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.SubscribeOnDispatcher<int>(default(IObservable<int>)));
+#endif
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn<int>(default(IObservable<int>), new SynchronizationContext()));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn<int>(someObservable, default(SynchronizationContext)));
-
-            ReactiveAssert.Throws<ArgumentNullException>(() => DispatcherObservable.SubscribeOnDispatcher<int>(default(IObservable<int>)));
         }
 
 #if HAS_WINFORMS
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_Control()
         {
             var lbl = CreateLabel();
@@ -289,10 +290,10 @@ namespace ReactiveTests.Tests
 
             evt.WaitOne();
             Application.Exit();
-            Assert.IsTrue(okay);
+            Assert.True(okay);
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_ControlScheduler()
         {
             var lbl = CreateLabel();
@@ -321,11 +322,12 @@ namespace ReactiveTests.Tests
 
             evt.WaitOne();
             Application.Exit();
-            Assert.IsTrue(okay);
+            Assert.True(okay);
         }
 #endif
 
-        [TestMethod]
+#if HAS_DISPATCHER
+        [Fact]
         [Asynchronous]
         public void SubscribeOn_Dispatcher()
         {
@@ -344,7 +346,7 @@ namespace ReactiveTests.Tests
                     return () =>
                     {
                         okay &= (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext);
-                        Assert.IsTrue(okay);
+                        Assert.True(okay);
                         dispatcher.InvokeShutdown();
                         evt.Set();
                     };
@@ -356,7 +358,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         [Asynchronous]
         public void SubscribeOn_DispatcherScheduler()
         {
@@ -375,7 +377,7 @@ namespace ReactiveTests.Tests
                     return () =>
                     {
                         okay &= (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext);
-                        Assert.IsTrue(okay);
+                        Assert.True(okay);
                         dispatcher.InvokeShutdown();
                         evt.Set();
                     };
@@ -387,7 +389,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         [Asynchronous]
         public void SubscribeOn_CurrentDispatcher()
         {
@@ -409,7 +411,7 @@ namespace ReactiveTests.Tests
                         return () =>
                         {
                             okay &= (SynchronizationContext.Current is System.Windows.Threading.DispatcherSynchronizationContext);
-                            Assert.IsTrue(okay);
+                            Assert.True(okay);
                             dispatcher.InvokeShutdown();
                             evt.Set();
                         };
@@ -421,12 +423,12 @@ namespace ReactiveTests.Tests
                 }));
             });
         }
+#endif
+#endregion
 
-        #endregion
-
-        #region + Synchronize +
+#region + Synchronize +
 
-        [TestMethod]
+        [Fact]
         public void Synchronize_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -437,7 +439,8 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Synchronize<int>(someObservable, null));
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void Synchronize_Range()
         {
             int i = 0;
@@ -447,9 +450,9 @@ namespace ReactiveTests.Tests
             lock (gate)
             {
                 outsideLock = false;
-                Observable.Range(0, 100, NewThreadScheduler.Default).Synchronize(gate).Subscribe(x => i++, () => { Assert.IsTrue(outsideLock); });
+                Observable.Range(0, 100, NewThreadScheduler.Default).Synchronize(gate).Subscribe(x => i++, () => { Assert.True(outsideLock); });
                 Thread.Sleep(100);
-                Assert.AreEqual(0, i);
+                Assert.Equal(0, i);
                 outsideLock = true;
             }
 
@@ -460,12 +463,12 @@ namespace ReactiveTests.Tests
                 {
                     int start = i;
                     Thread.Sleep(100);
-                    Assert.AreEqual(start, i);
+                    Assert.Equal(start, i);
                 }
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Synchronize_Throw()
         {
             var ex = new Exception();
@@ -477,9 +480,9 @@ namespace ReactiveTests.Tests
             lock (gate)
             {
                 outsideLock = false;
-                Observable.Throw<int>(ex, NewThreadScheduler.Default).Synchronize(gate).Subscribe(x => { Assert.Fail(); }, err => { lock (resLock) { e = err; } }, () => { Assert.IsTrue(outsideLock); });
+                Observable.Throw<int>(ex, NewThreadScheduler.Default).Synchronize(gate).Subscribe(x => { Assert.True(false); }, err => { lock (resLock) { e = err; } }, () => { Assert.True(outsideLock); });
                 Thread.Sleep(100);
-                Assert.IsNull(e);
+                Assert.Null(e);
                 outsideLock = true;
             }
 
@@ -492,10 +495,10 @@ namespace ReactiveTests.Tests
                 }
             }
 
-            Assert.AreSame(ex, e);
+            Assert.Same(ex, e);
         }
 
-        [TestMethod]
+        [Fact]
         public void Synchronize_BadObservable()
         {
             var o = Observable.Create<int>(obs =>
@@ -531,25 +534,25 @@ namespace ReactiveTests.Tests
 
             evt.WaitOne();
 
-            Assert.AreEqual(Enumerable.Range(0, 200).Sum(), sum);
+            Assert.Equal(Enumerable.Range(0, 200).Sum(), sum);
         }
-
-        #endregion
+#endif
+#endregion
     }
 
-    [TestClass]
+    
     public class ObservableConcurrencyReactiveTest : ReactiveTest
     {
-        #region + ObserveOn +
+#region + ObserveOn +
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Scheduler_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn(default(IObservable<int>), DummyScheduler.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ObserveOn(DummyObservable<int>.Instance, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Scheduler_Completed()
         {
             var scheduler = new TestScheduler();
@@ -592,7 +595,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Scheduler_Error()
         {
             var scheduler = new TestScheduler();
@@ -636,7 +639,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Scheduler_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -666,7 +669,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Scheduler_SameTime()
         {
             var scheduler = new TestScheduler();
@@ -690,7 +693,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_Scheduler_OnNextThrows()
         {
             var e = new ManualResetEvent(false);
@@ -706,7 +709,7 @@ namespace ReactiveTests.Tests
             );
 
             e.WaitOne();
-            Assert.IsNotNull(scheduler._exception);
+            Assert.NotNull(scheduler._exception);
         }
 
         class MyScheduler : IScheduler
@@ -750,7 +753,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF && !NO_CDS
-        [TestMethod]
+        [Fact]
         public void ObserveOn_LongRunning_Simple()
         {
             var started = default(ManualResetEvent);
@@ -771,10 +774,10 @@ namespace ReactiveTests.Tests
 
             end.WaitOne();
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { 1, 2, 3 }));
+            Assert.True(lst.SequenceEqual(new[] { 1, 2, 3 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_LongRunning_Error()
         {
             var started = default(ManualResetEvent);
@@ -797,10 +800,11 @@ namespace ReactiveTests.Tests
 
             end.WaitOne();
 
-            Assert.AreSame(ex_, err);
+            Assert.Same(ex_, err);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void ObserveOn_LongRunning_TimeVariance()
         {
             var started = default(ManualResetEvent);
@@ -829,8 +833,9 @@ namespace ReactiveTests.Tests
 
             end.WaitOne();
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_LongRunning_HoldUpDuringDispatchAndFail()
         {
             var started = default(ManualResetEvent);
@@ -859,11 +864,11 @@ namespace ReactiveTests.Tests
             resume.Set();
 
             end.WaitOne();
-            Assert.IsTrue(lst.SequenceEqual(new[] { 1, 2, 3 }));
-            Assert.AreSame(ex, err);
+            Assert.True(lst.SequenceEqual(new[] { 1, 2, 3 }));
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_LongRunning_Cancel()
         {
             var started = default(ManualResetEvent);
@@ -892,10 +897,10 @@ namespace ReactiveTests.Tests
 
             s.OnNext(4);
 
-            Assert.IsTrue(lst.Count > 0 && !lst.Contains(4));
+            Assert.True(lst.Count > 0 && !lst.Contains(4));
         }
 
-        [TestMethod]
+        [Fact]
         public void ObserveOn_LongRunning_OnNextThrows()
         {
             var started = default(ManualResetEvent);
@@ -924,12 +929,12 @@ namespace ReactiveTests.Tests
 
             stopped.WaitOne();
 
-            Assert.IsNotNull(exception);
+            Assert.NotNull(exception);
         }
 #endif
 
 #if !NO_SYNCCTX
-        [TestMethod]
+        [Fact]
         public void ObserveOn_SynchronizationContext_Simple()
         {
             var scheduler = new TestScheduler();
@@ -962,18 +967,18 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        #endregion
+#endregion
 
-        #region SubscribeOn
+#region SubscribeOn
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_Scheduler_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn(default(IObservable<int>), DummyScheduler.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SubscribeOn(DummyObservable<int>.Instance, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_Scheduler_Sleep()
         {
             var scheduler = new TestScheduler();
@@ -994,11 +999,11 @@ namespace ReactiveTests.Tests
             results.Messages.AssertEqual(
             );
 
-            Assert.AreEqual(201, s);
-            Assert.AreEqual(1001, d);
+            Assert.Equal(201, s);
+            Assert.Equal(1001, d);
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_Scheduler_Completed()
         {
             var scheduler = new TestScheduler();
@@ -1020,7 +1025,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_Scheduler_Error()
         {
             var scheduler = new TestScheduler();
@@ -1044,7 +1049,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_Scheduler_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1065,7 +1070,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_SYNCCTX
-        [TestMethod]
+        [Fact]
         public void SubscribeOn_SynchronizationContext_Simple()
         {
             var scheduler = new TestScheduler();
@@ -1098,9 +1103,9 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        #endregion
+#endregion
 
-        #region |> Helpers <|
+#region |> Helpers <|
 
 #if !NO_SYNCCTX
         class MyCtx : SynchronizationContext
@@ -1119,6 +1124,6 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        #endregion
+#endregion
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableConversionTests.cs

@@ -11,17 +11,17 @@ using System.Reactive.Subjects;
 using System.Reflection;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ObservableConversionTests : ReactiveTest
     {
         #region + Subscribe +
 
-        [TestMethod]
+        [Fact]
         public void SubscribeToEnumerable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Subscribe<int>((IEnumerable<int>)null, DummyObserver<int>.Instance));
@@ -33,7 +33,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<NullReferenceException>(() => NullEnumeratorEnumerable<int>.Instance.Subscribe(Observer.Create<int>(x => { }), Scheduler.CurrentThread));
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeToEnumerable_Finite()
         {
             var scheduler = new TestScheduler();
@@ -62,7 +62,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeToEnumerable_Infinite()
         {
             var scheduler = new TestScheduler();
@@ -94,7 +94,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubscribeToEnumerable_Error()
         {
             var scheduler = new TestScheduler();
@@ -123,7 +123,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !SILVERLIGHTM7
-        [TestMethod]
+        [Fact]
         public void SubscribeToEnumerable_DefaultScheduler()
         {
             for (int i = 0; i < 100; i++)
@@ -154,51 +154,51 @@ namespace ReactiveTests.Tests
 
         #region ToEnumerable
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToEnumerable(default(IObservable<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_Generic()
         {
-            Assert.IsTrue(Observable.Range(0, 10).ToEnumerable().SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(Observable.Range(0, 10).ToEnumerable().SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_NonGeneric()
         {
-            Assert.IsTrue(((IEnumerable)Observable.Range(0, 10).ToEnumerable()).Cast<int>().SequenceEqual(Enumerable.Range(0, 10)));
+            Assert.True(((IEnumerable)Observable.Range(0, 10).ToEnumerable()).Cast<int>().SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_ManualGeneric()
         {
             var res = Observable.Range(0, 10).ToEnumerable();
             var ieg = res.GetEnumerator();
             for (int i = 0; i < 10; i++)
             {
-                Assert.IsTrue(ieg.MoveNext());
-                Assert.AreEqual(i, ieg.Current);
+                Assert.True(ieg.MoveNext());
+                Assert.Equal(i, ieg.Current);
             }
-            Assert.IsFalse(ieg.MoveNext());
+            Assert.False(ieg.MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_ManualNonGeneric()
         {
             var res = (IEnumerable)Observable.Range(0, 10).ToEnumerable();
             var ien = res.GetEnumerator();
             for (int i = 0; i < 10; i++)
             {
-                Assert.IsTrue(ien.MoveNext());
-                Assert.AreEqual(i, ien.Current);
+                Assert.True(ien.MoveNext());
+                Assert.Equal(i, ien.Current);
             }
-            Assert.IsFalse(ien.MoveNext());
+            Assert.False(ien.MoveNext());
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEnumerable_ResetNotSupported()
         {
             ReactiveAssert.Throws<NotSupportedException>(() => Observable.Range(0, 10).ToEnumerable().GetEnumerator().Reset());
@@ -208,7 +208,7 @@ namespace ReactiveTests.Tests
 
         #region ToEvent
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_ArgumentChecks()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToEvent(default(IObservable<Unit>)));
@@ -216,7 +216,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToEvent(default(IObservable<EventPattern<EventArgs>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_Unit()
         {
             var src = new Subject<Unit>();
@@ -230,21 +230,21 @@ namespace ReactiveTests.Tests
 
             evt.OnNext += hnd;
 
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(1, num);
+            Assert.Equal(1, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
 
             evt.OnNext -= hnd;
 
             src.OnNext(new Unit());
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_NonUnit()
         {
             var src = new Subject<int>();
@@ -265,10 +265,10 @@ namespace ReactiveTests.Tests
 
             src.OnNext(3);
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { 1, 2 }));
+            Assert.True(lst.SequenceEqual(new[] { 1, 2 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_FromEvent()
         {
             var src = new Subject<int>();
@@ -277,7 +277,7 @@ namespace ReactiveTests.Tests
             var res = Observable.FromEvent<int>(h => evt.OnNext += h, h => evt.OnNext -= h);
 
             var lst = new List<int>();
-            using (res.Subscribe(e => lst.Add(e), () => Assert.Fail()))
+            using (res.Subscribe(e => lst.Add(e), () => Assert.True(false)))
             {
                 src.OnNext(1);
                 src.OnNext(2);
@@ -285,20 +285,20 @@ namespace ReactiveTests.Tests
 
             src.OnNext(3);
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { 1, 2 }));
+            Assert.True(lst.SequenceEqual(new[] { 1, 2 }));
         }
 
         #endregion
 
         #region ToEventPattern
 
-        [TestMethod]
+        [Fact]
         public void ToEventPattern_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToEventPattern<EventArgs>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEventPattern_IEvent()
         {
             var src = new Subject<EventPattern<EventArgs<int>>>();
@@ -309,7 +309,7 @@ namespace ReactiveTests.Tests
             var lst = new List<int>();
             var hnd = new EventHandler<EventArgs<int>>((s, e) =>
             {
-                Assert.AreSame(snd, s);
+                Assert.Same(snd, s);
                 lst.Add(e.Value);
             });
 
@@ -322,10 +322,10 @@ namespace ReactiveTests.Tests
 
             src.OnNext(new EventPattern<EventArgs<int>>(snd, new EventArgs<int>(44)));
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { 42, 43 }));
+            Assert.True(lst.SequenceEqual(new[] { 42, 43 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEventPattern_IEvent_Fails()
         {
             var src = new Subject<EventPattern<EventArgs<int>>>();
@@ -336,7 +336,7 @@ namespace ReactiveTests.Tests
             var lst = new List<int>();
             var hnd = new EventHandler<EventArgs<int>>((s, e) =>
             {
-                Assert.AreSame(snd, s);
+                Assert.Same(snd, s);
                 lst.Add(e.Value);
             });
 
@@ -349,10 +349,10 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws(ex, () => src.OnError(ex));
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { 42, 43 }));
+            Assert.True(lst.SequenceEqual(new[] { 42, 43 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEventPattern_IEvent_Completes()
         {
             var src = new Subject<EventPattern<EventArgs<int>>>();
@@ -363,7 +363,7 @@ namespace ReactiveTests.Tests
             var lst = new List<int>();
             var hnd = new EventHandler<EventArgs<int>>((s, e) =>
             {
-                Assert.AreSame(snd, s);
+                Assert.Same(snd, s);
                 lst.Add(e.Value);
             });
 
@@ -374,7 +374,7 @@ namespace ReactiveTests.Tests
 
             src.OnCompleted();
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { 42, 43 }));
+            Assert.True(lst.SequenceEqual(new[] { 42, 43 }));
         }
 
         class EventSrc
@@ -399,7 +399,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_ToEventPattern()
         {
             var src = new EventSrc();
@@ -410,7 +410,7 @@ namespace ReactiveTests.Tests
             var lst = new List<string>();
             var hnd = new EventHandler<EventArgs<string>>((s, e) =>
             {
-                Assert.AreSame(src, s);
+                Assert.Same(src, s);
                 lst.Add(e.Value);
             });
 
@@ -425,10 +425,10 @@ namespace ReactiveTests.Tests
 
             src.On("qux");
 
-            Assert.IsTrue(lst.SequenceEqual(new[] { "foo", "baz" }));
+            Assert.True(lst.SequenceEqual(new[] { "foo", "baz" }));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_DuplicateHandlers()
         {
             var src = new Subject<Unit>();
@@ -439,28 +439,28 @@ namespace ReactiveTests.Tests
 
             evt.OnNext += hnd;
 
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(1, num);
+            Assert.Equal(1, num);
 
             evt.OnNext += hnd;
 
             src.OnNext(new Unit());
-            Assert.AreEqual(3, num);
+            Assert.Equal(3, num);
 
             evt.OnNext -= hnd;
 
             src.OnNext(new Unit());
-            Assert.AreEqual(4, num);
+            Assert.Equal(4, num);
 
             evt.OnNext -= hnd;
 
             src.OnNext(new Unit());
-            Assert.AreEqual(4, num);
+            Assert.Equal(4, num);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_SourceCompletes()
         {
             var src = new Subject<Unit>();
@@ -471,24 +471,24 @@ namespace ReactiveTests.Tests
 
             evt.OnNext += hnd;
 
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(1, num);
+            Assert.Equal(1, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
 
             src.OnCompleted();
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
 
 #if !SILVERLIGHT // FieldAccessException
             var tbl = GetSubscriptionTable(evt);
-            Assert.IsTrue(tbl.Count == 0);
+            Assert.True(tbl.Count == 0);
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_SourceFails()
         {
             var src = new Subject<Unit>();
@@ -499,13 +499,13 @@ namespace ReactiveTests.Tests
 
             evt.OnNext += hnd;
 
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(1, num);
+            Assert.Equal(1, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
 
             var ex = new Exception();
 
@@ -513,11 +513,11 @@ namespace ReactiveTests.Tests
 
 #if !SILVERLIGHT // FieldAccessException
             var tbl = GetSubscriptionTable(evt);
-            Assert.IsTrue(tbl.Count == 0);
+            Assert.True(tbl.Count == 0);
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_DoneImmediately()
         {
             var src = Observable.Empty<Unit>();
@@ -530,16 +530,16 @@ namespace ReactiveTests.Tests
             {
                 evt.OnNext += hnd;
 
-                Assert.AreEqual(0, num);
+                Assert.Equal(0, num);
 
 #if !SILVERLIGHT // FieldAccessException
                 var tbl = GetSubscriptionTable(evt);
-                Assert.IsTrue(tbl.Count == 0);
+                Assert.True(tbl.Count == 0);
 #endif
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void ToEvent_UnbalancedHandlers()
         {
             var src = new Subject<Unit>();
@@ -549,28 +549,28 @@ namespace ReactiveTests.Tests
             var hnd = new Action<Unit>(e => num++);
 
             evt.OnNext += hnd;
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             evt.OnNext -= hnd;
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             evt.OnNext -= hnd;
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             evt.OnNext += hnd;
-            Assert.AreEqual(0, num);
+            Assert.Equal(0, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(1, num);
+            Assert.Equal(1, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
 
             evt.OnNext -= hnd;
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
 
             src.OnNext(new Unit());
-            Assert.AreEqual(2, num);
+            Assert.Equal(2, num);
         }
 
         private static Dictionary<Delegate, Stack<IDisposable>> GetSubscriptionTable(object evt)
@@ -578,25 +578,25 @@ namespace ReactiveTests.Tests
             return (Dictionary<Delegate, Stack<IDisposable>>)evt.GetType().GetField("_subscriptions", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(evt);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventPattern_Equality()
         {
             var e1 = new EventPattern<string, EventArgs>("Bart", EventArgs.Empty);
             var e2 = new EventPattern<string, EventArgs>("Bart", EventArgs.Empty);
 
-            Assert.IsTrue(e1.Equals(e1));
-            Assert.IsTrue(e1.Equals(e2));
-            Assert.IsTrue(e2.Equals(e1));
-            Assert.IsTrue(e1 == e2);
-            Assert.IsTrue(!(e1 != e2));
-            Assert.IsTrue(e1.GetHashCode() == e2.GetHashCode());
+            Assert.True(e1.Equals(e1));
+            Assert.True(e1.Equals(e2));
+            Assert.True(e2.Equals(e1));
+            Assert.True(e1 == e2);
+            Assert.True(!(e1 != e2));
+            Assert.True(e1.GetHashCode() == e2.GetHashCode());
 
-            Assert.IsFalse(e1.Equals(null));
-            Assert.IsFalse(e1.Equals("xy"));
-            Assert.IsFalse(e1 == null);
+            Assert.False(e1.Equals(null));
+            Assert.False(e1.Equals("xy"));
+            Assert.False(e1 == null);
         }
 
-        [TestMethod]
+        [Fact]
         public void EventPattern_Inequality()
         {
             var a1 = new MyEventArgs();
@@ -606,17 +606,17 @@ namespace ReactiveTests.Tests
             var e2 = new EventPattern<string, MyEventArgs>("John", a1);
             var e3 = new EventPattern<string, MyEventArgs>("Bart", a2);
 
-            Assert.IsTrue(!e1.Equals(e2));
-            Assert.IsTrue(!e2.Equals(e1));
-            Assert.IsTrue(!(e1 == e2));
-            Assert.IsTrue(e1 != e2);
-            Assert.IsTrue(e1.GetHashCode() != e2.GetHashCode());
+            Assert.True(!e1.Equals(e2));
+            Assert.True(!e2.Equals(e1));
+            Assert.True(!(e1 == e2));
+            Assert.True(e1 != e2);
+            Assert.True(e1.GetHashCode() != e2.GetHashCode());
 
-            Assert.IsTrue(!e1.Equals(e3));
-            Assert.IsTrue(!e3.Equals(e1));
-            Assert.IsTrue(!(e1 == e3));
-            Assert.IsTrue(e1 != e3);
-            Assert.IsTrue(e1.GetHashCode() != e3.GetHashCode());
+            Assert.True(!e1.Equals(e3));
+            Assert.True(!e3.Equals(e1));
+            Assert.True(!(e1 == e3));
+            Assert.True(e1 != e3);
+            Assert.True(e1.GetHashCode() != e3.GetHashCode());
         }
 
         class MyEventArgs : EventArgs
@@ -627,7 +627,7 @@ namespace ReactiveTests.Tests
 
         #region + ToObservable +
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToObservable((IEnumerable<int>)null, DummyScheduler.Instance));
@@ -636,7 +636,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<NullReferenceException>(() => Observable.ToObservable(NullEnumeratorEnumerable<int>.Instance, Scheduler.CurrentThread).Subscribe());
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_Complete()
         {
             var scheduler = new TestScheduler();
@@ -662,7 +662,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -686,7 +686,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_Error()
         {
             var scheduler = new TestScheduler();
@@ -712,14 +712,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_Default_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToObservable((IEnumerable<int>)null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ToObservable(DummyEnumerable<int>.Instance).Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_Default()
         {
             var xs = new[] { 4, 3, 1, 5, 9, 2 };
@@ -728,7 +728,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_LongRunning_Complete()
         {
             var start = default(ManualResetEvent);
@@ -745,10 +745,10 @@ namespace ReactiveTests.Tests
             start.WaitOne();
             end.WaitOne();
 
-            Assert.IsTrue(e.SequenceEqual(lst));
+            Assert.True(e.SequenceEqual(lst));
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_LongRunning_Dispose()
         {
             var start = default(ManualResetEvent);
@@ -770,10 +770,10 @@ namespace ReactiveTests.Tests
             d.Dispose();
             end.WaitOne();
 
-            Assert.IsTrue(e.Take(100).SequenceEqual(lst.Take(100)));
+            Assert.True(e.Take(100).SequenceEqual(lst.Take(100)));
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_LongRunning_Error()
         {
             var start = default(ManualResetEvent);
@@ -792,8 +792,8 @@ namespace ReactiveTests.Tests
             start.WaitOne();
             end.WaitOne();
 
-            Assert.IsTrue(new[] { 1, 2 }.SequenceEqual(lst));
-            Assert.AreSame(ex, err);
+            Assert.True(new[] { 1, 2 }.SequenceEqual(lst));
+            Assert.Same(ex, err);
         }
 #endif
 
@@ -804,7 +804,7 @@ namespace ReactiveTests.Tests
             throw ex;
         }
 
-        [TestMethod]
+        [Fact]
         public void EnumerableToObservable_GetEnumeratorThrows()
         {
             var ex = new Exception();

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableEventsTest.cs

@@ -11,18 +11,18 @@ using System.Reactive.Linq;
 using System.Reflection;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableEventsTest : ReactiveTest
     {
         #region + FromEventPattern +
 
         #region Strongly typed
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Conversion_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern(null, h => { }));
@@ -42,7 +42,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern<EventHandler, EventArgs>(h => new EventHandler(h), h => { }, h => { }, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_E2()
         {
             var scheduler = new TestScheduler();
@@ -69,7 +69,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Conversion_E4()
         {
             var scheduler = new TestScheduler();
@@ -97,7 +97,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Conversion_E5()
         {
             var scheduler = new TestScheduler();
@@ -124,7 +124,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_ConversionThrows()
         {
             var ex = new Exception();
@@ -139,12 +139,12 @@ namespace ReactiveTests.Tests
                 );
 
             var err = default(Exception);
-            res.Subscribe(_ => { Assert.Fail(); }, ex_ => err = ex_, () => { Assert.Fail(); });
+            res.Subscribe(_ => { Assert.True(false); }, ex_ => err = ex_, () => { Assert.True(false); });
 
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_E2_WithSender()
         {
             var scheduler = new TestScheduler();
@@ -171,7 +171,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_AddRemove_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern<EventArgs>(null, h => { }));
@@ -196,7 +196,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern<EventHandler, object, EventArgs>(h => { }, h => { }, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_AddRemove_E4()
         {
             var scheduler = new TestScheduler();
@@ -229,7 +229,7 @@ namespace ReactiveTests.Tests
 
         #region Instance events
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_ArgumentChecking()
         {
             ReactiveAssert.Throws</**/ArgumentNullException>(() => Observable.FromEventPattern(default(object), "foo"));
@@ -274,13 +274,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.FromEventPattern<FromEventPattern_ArgCheck, EventArgs>(new FromEventPattern_ArgCheck(), "foo"));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_InvalidVariance()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.FromEventPattern<CancelEventArgs>(new FromEventPattern_VarianceCheck(), "E1"));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_VarianceArgs()
         {
             var src = new FromEventPattern_VarianceCheck();
@@ -299,12 +299,12 @@ namespace ReactiveTests.Tests
 
             src.OnE2(new CancelEventArgs());
 
-            Assert.IsTrue(lst.Count == 2, "Count");
-            Assert.AreSame(e1, lst[0].EventArgs, "First");
-            Assert.AreSame(e2, lst[1].EventArgs, "Second");
+            Assert.True(lst.Count == 2, "Count");
+            Assert.True(ReferenceEquals(e1, lst[0].EventArgs), "First");
+            Assert.True(ReferenceEquals(e2, lst[1].EventArgs), "Second");
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_VarianceSender()
         {
             var src = new FromEventPattern_VarianceCheck();
@@ -323,12 +323,12 @@ namespace ReactiveTests.Tests
 
             src.OnE3("Fail!");
 
-            Assert.IsTrue(lst.Count == 2, "Count");
-            Assert.AreSame(s1, lst[0].Sender, "First");
-            Assert.AreSame(s2, lst[1].Sender, "Second");
+            Assert.True(lst.Count == 2, "Count");
+            Assert.True(ReferenceEquals(s1, lst[0].Sender), "First");
+            Assert.True(ReferenceEquals(s2, lst[1].Sender), "Second");
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_NonGeneric()
         {
             var src = new FromEventPattern_VarianceCheck();
@@ -351,12 +351,12 @@ namespace ReactiveTests.Tests
 
             src.OnE2(new CancelEventArgs());
 
-            Assert.IsTrue(lst.Count == 2, "Count");
-            Assert.AreSame(e1, lst[0].EventArgs, "First");
-            Assert.AreSame(e2, lst[1].EventArgs, "Second");
+            Assert.True(lst.Count == 2, "Count");
+            Assert.True(ReferenceEquals(e1, lst[0].EventArgs), "First");
+            Assert.True(ReferenceEquals(e2, lst[1].EventArgs), "Second");
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_Throws()
         {
             //
@@ -366,8 +366,8 @@ namespace ReactiveTests.Tests
             //
             var exAdd = default(Exception);
             var xs = Observable.FromEventPattern<FromEventPattern.TestEventArgs>(new FromEventPattern(), "AddThrows");
-            xs.Subscribe(_ => { Assert.Fail(); }, ex => exAdd = ex, () => { Assert.Fail(); });
-            Assert.IsTrue(exAdd is InvalidOperationException);
+            xs.Subscribe(_ => { Assert.True(false); }, ex => exAdd = ex, () => { Assert.True(false); });
+            Assert.True(exAdd is InvalidOperationException);
 
             //
             // Notice the exception propgation behavior is asymmetric by design. Below, the Dispose
@@ -379,11 +379,11 @@ namespace ReactiveTests.Tests
             //
             var exRem = default(Exception);
             var ys = Observable.FromEventPattern<FromEventPattern.TestEventArgs>(new FromEventPattern(), "RemoveThrows");
-            var d = ys.Subscribe(_ => { Assert.Fail(); }, ex => exRem = ex, () => { Assert.Fail(); });
+            var d = ys.Subscribe(_ => { Assert.True(false); }, ex => exRem = ex, () => { Assert.True(false); });
             ReactiveAssert.Throws<InvalidOperationException>(d.Dispose);
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_E1()
         {
             var scheduler = new TestScheduler();
@@ -408,7 +408,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_E2()
         {
             var scheduler = new TestScheduler();
@@ -433,7 +433,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_E2_WithSender()
         {
             var scheduler = new TestScheduler();
@@ -458,7 +458,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_E3()
         {
             var scheduler = new TestScheduler();
@@ -484,7 +484,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Instance_MissingAccessors()
         {
             var asm = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("EventsTest"), System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave);
@@ -520,7 +520,7 @@ namespace ReactiveTests.Tests
 
         #region Static events
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Static_ArgumentChecking()
         {
             ReactiveAssert.Throws</**/ArgumentNullException>(() => Observable.FromEventPattern(default(Type), "foo"));
@@ -545,7 +545,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.FromEventPattern<object, EventArgs>(typeof(FromEventPattern_ArgCheck), "foo"));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Static_E6()
         {
             var scheduler = new TestScheduler();
@@ -568,7 +568,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Static_E6_WithSender()
         {
             var scheduler = new TestScheduler();
@@ -591,7 +591,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Reflection_Static_NonGeneric_E6()
         {
             var scheduler = new TestScheduler();
@@ -622,7 +622,7 @@ namespace ReactiveTests.Tests
 
         #region + FromEvent +
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEvent<Action<int>, int>(default(Func<Action<int>, Action<int>>), h => { }, h => { }));
@@ -656,7 +656,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEvent(h => { }, h => { }, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_Action()
         {
             var fe = new FromEvent();
@@ -675,10 +675,10 @@ namespace ReactiveTests.Tests
 
             fe.OnA();
 
-            Assert.AreEqual(2, n);
+            Assert.Equal(2, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_ActionOfInt()
         {
             var fe = new FromEvent();
@@ -697,10 +697,10 @@ namespace ReactiveTests.Tests
 
             fe.OnB(4);
 
-            Assert.AreEqual(2 + 3, n);
+            Assert.Equal(2 + 3, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_ActionOfInt_SpecifiedExplicitly()
         {
             var fe = new FromEvent();
@@ -719,10 +719,10 @@ namespace ReactiveTests.Tests
 
             fe.OnB(4);
 
-            Assert.AreEqual(2 + 3, n);
+            Assert.Equal(2 + 3, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_ActionOfInt_SpecifiedExplicitly_TrivialConversion()
         {
             var fe = new FromEvent();
@@ -741,10 +741,10 @@ namespace ReactiveTests.Tests
 
             fe.OnB(4);
 
-            Assert.AreEqual(2 + 3, n);
+            Assert.Equal(2 + 3, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_MyAction()
         {
             var fe = new FromEvent();
@@ -763,14 +763,14 @@ namespace ReactiveTests.Tests
 
             fe.OnC(4);
 
-            Assert.AreEqual(2 + 3, n);
+            Assert.Equal(2 + 3, n);
         }
 
         #endregion
 
         #region Rx v2.0 behavior
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_ImplicitPublish()
         {
             var src = new MyEventSource();
@@ -780,73 +780,73 @@ namespace ReactiveTests.Tests
 
             var xs = Observable.FromEventPattern<MyEventArgs>(h => { addCount++; src.Bar += h; }, h => { src.Bar -= h; remCount++; }, Scheduler.Immediate);
 
-            Assert.AreEqual(0, addCount);
-            Assert.AreEqual(0, remCount);
+            Assert.Equal(0, addCount);
+            Assert.Equal(0, remCount);
 
             src.OnBar(41);
 
             var fst = new List<int>();
             var d1 = xs.Subscribe(e => fst.Add(e.EventArgs.Value));
 
-            Assert.AreEqual(1, addCount);
-            Assert.AreEqual(0, remCount);
+            Assert.Equal(1, addCount);
+            Assert.Equal(0, remCount);
 
             src.OnBar(42);
 
-            Assert.IsTrue(fst.SequenceEqual(new[] { 42 }));
+            Assert.True(fst.SequenceEqual(new[] { 42 }));
 
             d1.Dispose();
 
-            Assert.AreEqual(1, addCount);
-            Assert.AreEqual(1, remCount);
+            Assert.Equal(1, addCount);
+            Assert.Equal(1, remCount);
 
             var snd = new List<int>();
             var d2 = xs.Subscribe(e => snd.Add(e.EventArgs.Value));
 
-            Assert.AreEqual(2, addCount);
-            Assert.AreEqual(1, remCount);
+            Assert.Equal(2, addCount);
+            Assert.Equal(1, remCount);
 
             src.OnBar(43);
 
-            Assert.IsTrue(fst.SequenceEqual(new[] { 42 }));
-            Assert.IsTrue(snd.SequenceEqual(new[] { 43 }));
+            Assert.True(fst.SequenceEqual(new[] { 42 }));
+            Assert.True(snd.SequenceEqual(new[] { 43 }));
 
             var thd = new List<int>();
             var d3 = xs.Subscribe(e => thd.Add(e.EventArgs.Value));
 
-            Assert.AreEqual(2, addCount);
-            Assert.AreEqual(1, remCount);
+            Assert.Equal(2, addCount);
+            Assert.Equal(1, remCount);
 
             src.OnBar(44);
 
-            Assert.IsTrue(fst.SequenceEqual(new[] { 42 }));
-            Assert.IsTrue(snd.SequenceEqual(new[] { 43, 44 }));
-            Assert.IsTrue(thd.SequenceEqual(new[] { 44 }));
+            Assert.True(fst.SequenceEqual(new[] { 42 }));
+            Assert.True(snd.SequenceEqual(new[] { 43, 44 }));
+            Assert.True(thd.SequenceEqual(new[] { 44 }));
 
             d2.Dispose();
 
-            Assert.AreEqual(2, addCount);
-            Assert.AreEqual(1, remCount);
+            Assert.Equal(2, addCount);
+            Assert.Equal(1, remCount);
 
             src.OnBar(45);
 
-            Assert.IsTrue(fst.SequenceEqual(new[] { 42 }));
-            Assert.IsTrue(snd.SequenceEqual(new[] { 43, 44 }));
-            Assert.IsTrue(thd.SequenceEqual(new[] { 44, 45 }));
+            Assert.True(fst.SequenceEqual(new[] { 42 }));
+            Assert.True(snd.SequenceEqual(new[] { 43, 44 }));
+            Assert.True(thd.SequenceEqual(new[] { 44, 45 }));
 
             d3.Dispose();
 
-            Assert.AreEqual(2, addCount);
-            Assert.AreEqual(2, remCount);
+            Assert.Equal(2, addCount);
+            Assert.Equal(2, remCount);
 
             src.OnBar(46);
 
-            Assert.IsTrue(fst.SequenceEqual(new[] { 42 }));
-            Assert.IsTrue(snd.SequenceEqual(new[] { 43, 44 }));
-            Assert.IsTrue(thd.SequenceEqual(new[] { 44, 45 }));
+            Assert.True(fst.SequenceEqual(new[] { 42 }));
+            Assert.True(snd.SequenceEqual(new[] { 43, 44 }));
+            Assert.True(thd.SequenceEqual(new[] { 44, 45 }));
         }
-
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void FromEvent_SynchronizationContext()
         {
             var beforeSubscribeNull = false;
@@ -873,8 +873,8 @@ namespace ReactiveTests.Tests
 
                 var xs = Observable.FromEventPattern<MyEventArgs>(h => { addCtx = SynchronizationContext.Current; src.Bar += h; addEvt.Set(); }, h => { remCtx = SynchronizationContext.Current; src.Bar -= h; remEvt.Set(); });
 
-                Assert.IsNull(addCtx);
-                Assert.IsNull(remCtx);
+                Assert.Null(addCtx);
+                Assert.Null(remCtx);
 
                 var d = default(IDisposable);
                 var res = new List<int>();
@@ -917,17 +917,17 @@ namespace ReactiveTests.Tests
                 thdNext = res.SequenceEqual(new[] { 42, 43 });
             });
 
-            Assert.IsTrue(beforeSubscribeNull);
-            Assert.IsTrue(subscribeOnCtx);
-            Assert.IsTrue(afterSubscribeNull);
+            Assert.True(beforeSubscribeNull);
+            Assert.True(subscribeOnCtx);
+            Assert.True(afterSubscribeNull);
 
-            Assert.IsTrue(fstNext);
-            Assert.IsTrue(sndNext);
-            Assert.IsTrue(thdNext);
+            Assert.True(fstNext);
+            Assert.True(sndNext);
+            Assert.True(thdNext);
 
-            Assert.IsTrue(beforeDisposeNull);
-            Assert.IsTrue(disposeOnCtx);
-            Assert.IsTrue(afterDisposeNull);
+            Assert.True(beforeDisposeNull);
+            Assert.True(disposeOnCtx);
+            Assert.True(afterDisposeNull);
         }
 
         private void RunWithContext<T>(T ctx, Action<T> run)
@@ -942,38 +942,39 @@ namespace ReactiveTests.Tests
             t.Start();
             t.Join();
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_Scheduler1()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent<MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_Scheduler2()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent(h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_Scheduler3()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent<Action<MyEventArgs>, MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEvent_Scheduler4()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent<Action, MyEventArgs>(h => () => { }, h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler1()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler2()
         {
             RunWithScheduler((s, add, remove) =>
@@ -984,7 +985,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler3()
         {
             RunWithScheduler((s, add, remove) =>
@@ -995,13 +996,13 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler4()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern(h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler5()
         {
             RunWithScheduler((s, add, remove) =>
@@ -1012,7 +1013,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler6()
         {
             RunWithScheduler((s, add, remove) =>
@@ -1023,19 +1024,19 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler7()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<EventHandler<MyEventArgs>, MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler8()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<EventHandler<MyEventArgs>, MyEventArgs>(h => h, h => { add(); }, h => { remove(); }, s));
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler9()
         {
             RunWithScheduler((s, add, remove) =>
@@ -1046,7 +1047,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler10()
         {
             RunWithScheduler((s, add, remove) =>
@@ -1057,7 +1058,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void FromEventPattern_Scheduler11()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<EventHandler<MyEventArgs>, object, MyEventArgs>(h => { add(); }, h => { remove(); }, s));
@@ -1094,29 +1095,29 @@ namespace ReactiveTests.Tests
 
             var xs = run(s, add, rem);
 
-            Assert.AreEqual(0, n);
-            Assert.AreEqual(0, a);
-            Assert.AreEqual(0, r);
+            Assert.Equal(0, n);
+            Assert.Equal(0, a);
+            Assert.Equal(0, r);
 
             var d1 = xs.Subscribe();
-            Assert.AreEqual(1, n);
-            Assert.AreEqual(1, a);
-            Assert.AreEqual(0, r);
+            Assert.Equal(1, n);
+            Assert.Equal(1, a);
+            Assert.Equal(0, r);
 
             var d2 = xs.Subscribe();
-            Assert.AreEqual(1, n);
-            Assert.AreEqual(1, a);
-            Assert.AreEqual(0, r);
+            Assert.Equal(1, n);
+            Assert.Equal(1, a);
+            Assert.Equal(0, r);
 
             d1.Dispose();
-            Assert.AreEqual(1, n);
-            Assert.AreEqual(1, a);
-            Assert.AreEqual(0, r);
+            Assert.Equal(1, n);
+            Assert.Equal(1, a);
+            Assert.Equal(0, r);
 
             d2.Dispose();
-            Assert.AreEqual(2, n);
-            Assert.AreEqual(1, a);
-            Assert.AreEqual(1, r);
+            Assert.Equal(2, n);
+            Assert.Equal(1, a);
+            Assert.Equal(1, r);
         }
 
         class MyEventSource
@@ -1184,9 +1185,9 @@ namespace ReactiveTests.Tests
         }
 
 
-        #endregion
+#endregion
 
-        #region <| Helpers |>
+#region <| Helpers |>
 
         class FromEventPattern_ArgCheck
         {
@@ -1355,6 +1356,6 @@ namespace ReactiveTests.Tests
             }
         }
 
-        #endregion
+#endregion
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableExTest.cs

@@ -7,17 +7,17 @@ using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class ObservableExTest : ReactiveTest
     {
         #region Create
 
-        [TestMethod]
+        [Fact]
         public void Iterate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create<int>(default(Func<IObserver<int>, IEnumerable<IObservable<Object>>>)));
@@ -39,7 +39,7 @@ namespace ReactiveTests.Tests
             observer.OnNext(4);
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Complete()
         {
             var scheduler = new TestScheduler();
@@ -103,7 +103,7 @@ namespace ReactiveTests.Tests
             observer.OnNext(4);
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Complete_Implicit()
         {
             var scheduler = new TestScheduler();
@@ -173,7 +173,7 @@ namespace ReactiveTests.Tests
             observer.OnCompleted();
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Iterator_Throw()
         {
             var scheduler = new TestScheduler();
@@ -242,7 +242,7 @@ namespace ReactiveTests.Tests
             observer.OnCompleted();
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Iterator_Error()
         {
             var scheduler = new TestScheduler();
@@ -306,7 +306,7 @@ namespace ReactiveTests.Tests
             observer.OnNext(4);
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Complete_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -359,7 +359,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void IteratorScenario()
         {
             var xs = ObservableEx.Create<int>(o => _IteratorScenario(100, 1000, o));
@@ -380,7 +380,7 @@ namespace ReactiveTests.Tests
             results.OnNext(ys.Value);
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Void_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(default(Func<IEnumerable<IObservable<object>>>)));
@@ -396,7 +396,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new Object());
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Void_Complete()
         {
             var scheduler = new TestScheduler();
@@ -452,7 +452,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new Object());
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Void_Complete_Implicit()
         {
             var scheduler = new TestScheduler();
@@ -511,7 +511,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new Object());
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Void_Iterator_Throw()
         {
             var scheduler = new TestScheduler();
@@ -568,7 +568,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new Object());
         }
 
-        [TestMethod]
+        [Fact]
         public void Iterate_Void_Complete_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -618,8 +618,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
-        [Ignore]
+        [Fact(Skip ="")]
         public void Iterate_Void_Func_Throw()
         {
             var scheduler = new TestScheduler();
@@ -636,7 +635,7 @@ namespace ReactiveTests.Tests
             yield return ys;
         }
 
-        [TestMethod]
+        [Fact]
         public void IteratorScenario_Void()
         {
             var xs = ObservableEx.Create(() => _IteratorScenario_Void(100, 1000));
@@ -648,7 +647,7 @@ namespace ReactiveTests.Tests
 
         #region Expand
 
-        [TestMethod]
+        [Fact]
         public void Expand_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Expand(null, DummyFunc<int, IObservable<int>>.Instance, DummyScheduler.Instance));
@@ -658,16 +657,16 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Expand(DummyObservable<int>.Instance, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Default()
         {
             var b = Observable.Return(1).Expand(x => x < 10 ? Observable.Return(x + 1) : Observable.Empty<int>())
                         .SequenceEqual(Observable.Range(1, 10)).First();
 
-            Assert.IsTrue(b);
+            Assert.True(b);
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Empty()
         {
             var scheduler = new TestScheduler();
@@ -693,7 +692,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Error()
         {
             var scheduler = new TestScheduler();
@@ -721,7 +720,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Never()
         {
             var scheduler = new TestScheduler();
@@ -745,7 +744,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Basic()
         {
             var scheduler = new TestScheduler();
@@ -786,7 +785,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Expand_Throw()
         {
             var scheduler = new TestScheduler();
@@ -817,7 +816,7 @@ namespace ReactiveTests.Tests
 
         #region ForkJoin
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ArgumentChecking()
         {
             var someObservable = DummyObservable<int>.Instance;
@@ -829,7 +828,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ForkJoin((IEnumerable<IObservable<int>>)null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_EmptyEmpty()
         {
             var scheduler = new TestScheduler();
@@ -853,7 +852,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_None()
         {
             var scheduler = new TestScheduler();
@@ -864,7 +863,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_EmptyReturn()
         {
             var scheduler = new TestScheduler();
@@ -889,7 +888,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ReturnEmpty()
         {
             var scheduler = new TestScheduler();
@@ -914,7 +913,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ReturnReturn()
         {
             var scheduler = new TestScheduler();
@@ -941,7 +940,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_EmptyThrow()
         {
             var ex = new Exception();
@@ -968,7 +967,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ThrowEmpty()
         {
             var ex = new Exception();
@@ -995,7 +994,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ReturnThrow()
         {
             var ex = new Exception();
@@ -1023,7 +1022,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ThrowReturn()
         {
             var ex = new Exception();
@@ -1051,7 +1050,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_Binary()
         {
             var scheduler = new TestScheduler();
@@ -1080,7 +1079,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_NaryParams()
         {
             var scheduler = new TestScheduler();
@@ -1118,7 +1117,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_NaryParamsEmpty()
         {
             var scheduler = new TestScheduler();
@@ -1152,7 +1151,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_NaryParamsEmptyBeforeEnd()
         {
             var scheduler = new TestScheduler();
@@ -1186,13 +1185,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_Nary_Immediate()
         {
             ObservableEx.ForkJoin(Observable.Return(1), Observable.Return(2)).First().SequenceEqual(new[] { 1, 2 });
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_Nary_Virtual_And_Immediate()
         {
             var scheduler = new TestScheduler();
@@ -1230,7 +1229,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_Nary_Immediate_And_Virtual()
         {
             var scheduler = new TestScheduler();
@@ -1268,7 +1267,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_Nary()
         {
             var scheduler = new TestScheduler();
@@ -1306,7 +1305,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1302_SelectorThrows_LeftLast()
         {
             var scheduler = new TestScheduler();
@@ -1338,7 +1337,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1302_SelectorThrows_RightLast()
         {
             var scheduler = new TestScheduler();
@@ -1370,7 +1369,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1302_RightLast_NoLeft()
         {
             var scheduler = new TestScheduler();
@@ -1399,7 +1398,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1302_RightLast_NoRight()
         {
             var scheduler = new TestScheduler();
@@ -1432,7 +1431,7 @@ namespace ReactiveTests.Tests
 
         #region Let
 
-        [TestMethod]
+        [Fact]
         public void Let_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -1441,19 +1440,19 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Let<int, int>(someObservable, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Let_CallsFunctionImmediately()
         {
             bool called = false;
             Observable.Empty<int>().Let(x => { called = true; return x; });
-            Assert.IsTrue(called);
+            Assert.True(called);
         }
 
         #endregion
 
         #region ManySelect
 
-        [TestMethod]
+        [Fact]
         public void ManySelect_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(null, DummyFunc<IObservable<int>, int>.Instance, DummyScheduler.Instance));
@@ -1463,7 +1462,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ManySelect<int, int>(DummyObservable<int>.Instance, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ManySelect_Law_1()
         {
             var xs = Observable.Range(1, 0);
@@ -1471,10 +1470,10 @@ namespace ReactiveTests.Tests
             var left = xs.ManySelect(Observable.First);
             var right = xs;
 
-            Assert.IsTrue(left.SequenceEqual(right).First());
+            Assert.True(left.SequenceEqual(right).First());
         }
 
-        [TestMethod]
+        [Fact]
         public void ManySelect_Law_2()
         {
             var xs = Observable.Range(1, 10);
@@ -1483,10 +1482,10 @@ namespace ReactiveTests.Tests
             var left = xs.ManySelect(f).First();
             var right = f(xs);
 
-            Assert.AreEqual(left, right);
+            Assert.Equal(left, right);
         }
 
-        [TestMethod]
+        [Fact]
         public void ManySelect_Law_3()
         {
             var xs = Observable.Range(1, 10);
@@ -1496,10 +1495,10 @@ namespace ReactiveTests.Tests
             var left = xs.ManySelect(f).ManySelect(g);
             var right = xs.ManySelect(ys => g(ys.ManySelect(f)));
 
-            Assert.IsTrue(left.SequenceEqual(right).First());
+            Assert.True(left.SequenceEqual(right).First());
         }
 
-        [TestMethod]
+        [Fact]
         public void ManySelect_Basic()
         {
             var scheduler = new TestScheduler();
@@ -1528,7 +1527,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ManySelect_Error()
         {
             var scheduler = new TestScheduler();
@@ -1563,14 +1562,14 @@ namespace ReactiveTests.Tests
 
         #region ToListObservable
 
-        [TestMethod]
+        [Fact]
         public void ToListObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).ToListObservable());
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Never<int>().ToListObservable().Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToListObservable_OnNext()
         {
             var scheduler = new TestScheduler();
@@ -1590,7 +1589,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ToListObservable_OnError()
         {
             var scheduler = new TestScheduler();
@@ -1621,7 +1620,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ToListObservable_OnCompleted()
         {
             var scheduler = new TestScheduler();
@@ -1645,10 +1644,10 @@ namespace ReactiveTests.Tests
                 OnCompleted<Object>(600)
             );
 
-            Assert.AreEqual(3, s.Value);
+            Assert.Equal(3, s.Value);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToListObservable_Disposed()
         {
             var scheduler = new TestScheduler();
@@ -1671,7 +1670,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ToListObservable_Never()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableExtensionsTest.cs

@@ -6,17 +6,17 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using System.Collections.Generic;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableExtensionsTest : ReactiveTest
     {
         #region Subscribe
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -40,13 +40,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, (Exception _) => { }, default(Action)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_None_Return()
         {
             Observable.Return(1, Scheduler.Immediate).Subscribe();
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_None_Throw()
         {
             var ex = new Exception();
@@ -56,62 +56,62 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Subscribe());
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_None_Empty()
         {
-            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.Fail(); });
+            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.True(false); });
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_OnNext_Return()
         {
             int _x = -1;
             Observable.Return(42, Scheduler.Immediate).Subscribe((int x) => { _x = x; });
-            Assert.AreEqual(42, _x);
+            Assert.Equal(42, _x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_OnNext_Throw()
         {
             var ex = new Exception();
 
             var xs = Observable.Throw<int>(ex, Scheduler.Immediate);
 
-            ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.Fail(); }));
+            ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.True(false); }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_OnNext_Empty()
         {
-            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.Fail(); });
+            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.True(false); });
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_OnNextOnCompleted_Return()
         {
             bool finished = false;
             int _x = -1;
             Observable.Return(42, Scheduler.Immediate).Subscribe((int x) => { _x = x; }, () => { finished = true; });
-            Assert.AreEqual(42, _x);
-            Assert.IsTrue(finished);
+            Assert.Equal(42, _x);
+            Assert.True(finished);
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_OnNextOnCompleted_Throw()
         {
             var ex = new Exception();
 
             var xs = Observable.Throw<int>(ex, Scheduler.Immediate);
 
-            ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.Fail(); }, () => { Assert.Fail(); }));
+            ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.True(false); }, () => { Assert.True(false); }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_OnNextOnCompleted_Empty()
         {
             bool finished = false;
-            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.Fail(); }, () => { finished = true; });
-            Assert.IsTrue(finished);
+            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.True(false); }, () => { finished = true; });
+            Assert.True(finished);
         }
 
         #endregion
@@ -120,7 +120,7 @@ namespace ReactiveTests.Tests
 
 #if !NO_TPL
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -149,7 +149,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, (Exception _) => { }, default(Action), ct));
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_None()
         {
             var scheduler = new TestScheduler();
@@ -179,7 +179,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_CancelBeforeBegin()
         {
             var scheduler = new TestScheduler();
@@ -207,7 +207,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_CancelMiddle()
         {
             var scheduler = new TestScheduler();
@@ -238,7 +238,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_CancelAfterEnd()
         {
             var scheduler = new TestScheduler();
@@ -273,7 +273,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_NeverCancel()
         {
             var scheduler = new TestScheduler();
@@ -305,12 +305,12 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_Overloads_AlreadyCancelled()
         {
             var xs = Observable.Defer<int>(() =>
             {
-                Assert.Fail();
+                Assert.True(false);
                 return Observable.Return(42, Scheduler.Immediate);
             });
 
@@ -325,7 +325,7 @@ namespace ReactiveTests.Tests
             xs.Subscribe(Observer.Create<int>(_ => { }, ex => { }, () => { }), cts.Token);
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_Overloads_None()
         {
             var i = 0;
@@ -346,13 +346,13 @@ namespace ReactiveTests.Tests
             xs.Subscribe(_ => { n++; }, ex => { e++; }, () => { c++; }, CancellationToken.None);
             xs.Subscribe(Observer.Create<int>(_ => { n++; }, ex => { e++; }, () => { c++; }), CancellationToken.None);
 
-            Assert.AreEqual(6, i);
-            Assert.AreEqual(5, n);
-            Assert.AreEqual(0, e);
-            Assert.AreEqual(3, c);
+            Assert.Equal(6, i);
+            Assert.Equal(5, n);
+            Assert.Equal(0, e);
+            Assert.Equal(3, c);
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_CT_CancelDuringCallback()
         {
             var scheduler = new TestScheduler();
@@ -378,7 +378,7 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.AreEqual(2, n);
+            Assert.Equal(2, n);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(200, 220)

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableImperativeTest.cs

@@ -8,7 +8,7 @@ using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 #if !NO_TPL
@@ -17,13 +17,13 @@ using System.Threading.Tasks;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableImperativeTest : ReactiveTest
     {
         #region ForEachAsync
 
 #if !NO_TPL
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ForEachAsync(default(IObservable<int>), x => { }));
@@ -37,7 +37,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ForEachAsync(Observable.Never<int>(), default(Action<int, int>), CancellationToken.None));
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Never()
         {
             var scheduler = new TestScheduler();
@@ -69,10 +69,10 @@ namespace ReactiveTests.Tests
                 new Recorded<int>(500, 5)
             );
 
-            Assert.AreEqual(TaskStatus.WaitingForActivation, task.Status);
+            Assert.Equal(TaskStatus.WaitingForActivation, task.Status);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Completed()
         {
             var scheduler = new TestScheduler();
@@ -105,10 +105,10 @@ namespace ReactiveTests.Tests
                 new Recorded<int>(500, 5)
             );
 
-            Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
+            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Error()
         {
             var scheduler = new TestScheduler();
@@ -143,11 +143,11 @@ namespace ReactiveTests.Tests
                 new Recorded<int>(500, 5)
             );
 
-            Assert.AreEqual(TaskStatus.Faulted, task.Status);
-            Assert.AreSame(exception, task.Exception.InnerException);
+            Assert.Equal(TaskStatus.Faulted, task.Status);
+            Assert.Same(exception, task.Exception.InnerException);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Throw()
         {
             var scheduler = new TestScheduler();
@@ -186,11 +186,11 @@ namespace ReactiveTests.Tests
                 new Recorded<int>(400, 4)
             );
 
-            Assert.AreEqual(TaskStatus.Faulted, task.Status);
-            Assert.AreSame(exception, task.Exception.InnerException);
+            Assert.Equal(TaskStatus.Faulted, task.Status);
+            Assert.Same(exception, task.Exception.InnerException);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_CancelDuring()
         {
             var scheduler = new TestScheduler();
@@ -222,10 +222,10 @@ namespace ReactiveTests.Tests
                 new Recorded<int>(300, 3)
             );
 
-            Assert.AreEqual(TaskStatus.Canceled, task.Status);
+            Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_CancelBefore()
         {
             var scheduler = new TestScheduler();
@@ -255,10 +255,10 @@ namespace ReactiveTests.Tests
             list.AssertEqual(
             );
 
-            Assert.AreEqual(TaskStatus.Canceled, task.Status);
+            Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_CancelAfter()
         {
             var scheduler = new TestScheduler();
@@ -292,10 +292,10 @@ namespace ReactiveTests.Tests
                 new Recorded<int>(500, 5)
             );
 
-            Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);
+            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Default()
         {
             var list = new List<int>();
@@ -303,7 +303,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Index()
         {
             var list = new List<int>();
@@ -311,7 +311,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(3 * 0, 4 * 1, 5 * 2, 6 * 3, 7 * 4);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Default_Cancel()
         {
             var N = 10;
@@ -353,14 +353,14 @@ namespace ReactiveTests.Tests
                     ;
 
                 for (int i = 0; i < 10; i++)
-                    Assert.AreEqual(42, lst[i]);
+                    Assert.Equal(42, lst[i]);
 
-                Assert.IsTrue(done);
-                Assert.IsTrue(t.IsCanceled);
+                Assert.True(done);
+                Assert.True(t.IsCanceled);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_Index_Cancel()
         {
             var N = 10;
@@ -402,14 +402,14 @@ namespace ReactiveTests.Tests
                     ;
 
                 for (int i = 0; i < 10; i++)
-                    Assert.AreEqual(i * 42, lst[i]);
+                    Assert.Equal(i * 42, lst[i]);
 
-                Assert.IsTrue(done);
-                Assert.IsTrue(t.IsCanceled);
+                Assert.True(done);
+                Assert.True(t.IsCanceled);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_DisposeThrows1()
         {
             var cts = new CancellationTokenSource();
@@ -443,11 +443,11 @@ namespace ReactiveTests.Tests
             }
             catch
             {
-                Assert.Fail();
+                Assert.True(false);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_DisposeThrows2()
         {
             var cts = new CancellationTokenSource();
@@ -484,12 +484,13 @@ namespace ReactiveTests.Tests
             }
             catch (AggregateException err)
             {
-                Assert.AreEqual(1, err.InnerExceptions.Count);
-                Assert.AreSame(ex, err.InnerExceptions[0]);
+                Assert.Equal(1, err.InnerExceptions.Count);
+                Assert.Same(ex, err.InnerExceptions[0]);
             }
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void ForEachAsync_DisposeThrows()
         {
             //
@@ -536,13 +537,14 @@ namespace ReactiveTests.Tests
                 }
                 catch (AggregateException err)
                 {
-                    Assert.AreEqual(1, err.InnerExceptions.Count);
-                    Assert.AreSame(ex, err.InnerExceptions[0]);
+                    Assert.Equal(1, err.InnerExceptions.Count);
+                    Assert.Same(ex, err.InnerExceptions[0]);
                 }
             }
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void ForEachAsync_SubscribeThrows()
         {
             var ex = new Exception();
@@ -560,21 +562,21 @@ namespace ReactiveTests.Tests
             try
             {
                 t.Wait();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (AggregateException err)
             {
-                Assert.AreEqual(1, err.InnerExceptions.Count);
-                Assert.AreSame(ex, err.InnerExceptions[0]);
+                Assert.Equal(1, err.InnerExceptions.Count);
+                Assert.Same(ex, err.InnerExceptions[0]);
             }
         }
 #endif
 
-        #endregion
+#endregion
 
         #region + Case +
 
-        [TestMethod]
+        [Fact]
         public void Case_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Case(null, new Dictionary<int, IObservable<int>>(), DummyObservable<int>.Instance));
@@ -589,7 +591,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Case<int, int>(DummyFunc<int>.Instance, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Case_One()
         {
             var scheduler = new TestScheduler();
@@ -641,7 +643,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Case_Two()
         {
             var scheduler = new TestScheduler();
@@ -693,7 +695,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Case_Three()
         {
             var scheduler = new TestScheduler();
@@ -745,7 +747,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Case_Throw()
         {
             var scheduler = new TestScheduler();
@@ -795,7 +797,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void CaseWithDefault_One()
         {
             var scheduler = new TestScheduler();
@@ -837,7 +839,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void CaseWithDefault_Two()
         {
             var scheduler = new TestScheduler();
@@ -879,7 +881,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void CaseWithDefault_Three()
         {
             var scheduler = new TestScheduler();
@@ -917,7 +919,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void CaseWithDefault_Throw()
         {
             var scheduler = new TestScheduler();
@@ -957,14 +959,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void CaseWithDefault_CheckDefault()
         {
             Observable.Case(() => 1, new Dictionary<int, IObservable<int>>(), DefaultScheduler.Instance)
                 .AssertEqual(Observable.Case(() => 1, new Dictionary<int, IObservable<int>>()));
         }
 
-        [TestMethod]
+        [Fact]
         public void Case_Error()
         {
             var scheduler = new TestScheduler();
@@ -1012,14 +1014,14 @@ namespace ReactiveTests.Tests
 
         #region + DoWhile +
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DoWhile(DummyObservable<int>.Instance, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DoWhile(default(IObservable<int>), DummyFunc<bool>.Instance));
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_AlwaysFalse()
         {
             var scheduler = new TestScheduler();
@@ -1047,7 +1049,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_AlwaysTrue()
         {
             var scheduler = new TestScheduler();
@@ -1085,7 +1087,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_AlwaysTrue_Throw()
         {
             var scheduler = new TestScheduler();
@@ -1107,7 +1109,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_AlwaysTrue_Infinite()
         {
             var scheduler = new TestScheduler();
@@ -1127,7 +1129,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_SometimesTrue()
         {
             var scheduler = new TestScheduler();
@@ -1167,7 +1169,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void DoWhile_SometimesThrows()
         {
             var scheduler = new TestScheduler();
@@ -1213,14 +1215,14 @@ namespace ReactiveTests.Tests
 
         #region + For +
 
-        [TestMethod]
+        [Fact]
         public void For_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.For(DummyEnumerable<int>.Instance, default(Func<int, IObservable<int>>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.For(null, DummyFunc<int, IObservable<int>>.Instance));
         }
 
-        [TestMethod]
+        [Fact]
         public void For_Basic()
         {
             var scheduler = new TestScheduler();
@@ -1253,7 +1255,7 @@ namespace ReactiveTests.Tests
             throw ex;
         }
 
-        [TestMethod]
+        [Fact]
         public void For_Error_Iterator()
         {
             var scheduler = new TestScheduler();
@@ -1280,7 +1282,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void For_Error_Source()
         {
             var scheduler = new TestScheduler();
@@ -1294,7 +1296,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void For_SelectorThrows()
         {
             var scheduler = new TestScheduler();
@@ -1312,7 +1314,7 @@ namespace ReactiveTests.Tests
 
         #region + If +
 
-        [TestMethod]
+        [Fact]
         public void If_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If(null, DummyObservable<int>.Instance, DummyObservable<int>.Instance));
@@ -1323,7 +1325,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If(DummyFunc<bool>.Instance, DummyObservable<int>.Instance, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void If_True()
         {
             var scheduler = new TestScheduler();
@@ -1356,7 +1358,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_False()
         {
             var scheduler = new TestScheduler();
@@ -1389,7 +1391,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Throw()
         {
             var scheduler = new TestScheduler();
@@ -1421,7 +1423,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1452,14 +1454,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Default_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If<int>(null, DummyObservable<int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.If<int>(DummyFunc<bool>.Instance, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Default_Completed()
         {
             var scheduler = new TestScheduler();
@@ -1488,7 +1490,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Default_Error()
         {
             var scheduler = new TestScheduler();
@@ -1519,7 +1521,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Default_Never()
         {
             var scheduler = new TestScheduler();
@@ -1546,7 +1548,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Default_Other()
         {
             var scheduler = new TestScheduler();
@@ -1572,7 +1574,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void If_Default_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -1598,14 +1600,14 @@ namespace ReactiveTests.Tests
 
         #region + While +
 
-        [TestMethod]
+        [Fact]
         public void While_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.While(default(Func<bool>), DummyObservable<int>.Instance));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.While(DummyFunc<bool>.Instance, default(IObservable<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void While_AlwaysFalse()
         {
             var scheduler = new TestScheduler();
@@ -1628,7 +1630,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void While_AlwaysTrue()
         {
             var scheduler = new TestScheduler();
@@ -1666,7 +1668,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void While_AlwaysTrue_Throw()
         {
             var scheduler = new TestScheduler();
@@ -1688,7 +1690,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void While_AlwaysTrue_Infinite()
         {
             var scheduler = new TestScheduler();
@@ -1708,7 +1710,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void While_SometimesTrue()
         {
             var scheduler = new TestScheduler();
@@ -1748,7 +1750,7 @@ namespace ReactiveTests.Tests
             throw ex;
         }
 
-        [TestMethod]
+        [Fact]
         public void While_SometimesThrows()
         {
             var scheduler = new TestScheduler();
@@ -1788,8 +1790,8 @@ namespace ReactiveTests.Tests
         #endregion
 
         #region General tests for loops
-
-        [TestMethod]
+#if HAS_STACKTRACE
+        [Fact]
         public void LoopTest1()
         {
             var loop = Observable.Defer(() =>
@@ -1815,11 +1817,11 @@ namespace ReactiveTests.Tests
                 std.Add(new System.Diagnostics.StackTrace().FrameCount);
             });
 
-            Assert.IsTrue(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4 }));
-            Assert.IsTrue(std.Distinct().Count() == 1);
+            Assert.True(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4 }));
+            Assert.True(std.Distinct().Count() == 1);
         }
 
-        [TestMethod]
+        [Fact]
         public void LoopTest2()
         {
             var n = 0;
@@ -1841,10 +1843,10 @@ namespace ReactiveTests.Tests
                 std.Add(new System.Diagnostics.StackTrace().FrameCount);
             });
 
-            Assert.IsTrue(res.SequenceEqual(Enumerable.Repeat(42, 10)));
-            Assert.IsTrue(std.Distinct().Count() == 1);
+            Assert.True(res.SequenceEqual(Enumerable.Repeat(42, 10)));
+            Assert.True(std.Distinct().Count() == 1);
         }
-
-        #endregion
+#endif
+#endregion
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableJoinsTest.cs

@@ -5,16 +5,16 @@ using System.Collections.Generic;
 using System.Reactive.Joins;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableWhensTest : ReactiveTest
     {
         #region And
 
-        [TestMethod]
+        [Fact]
         public void And_ArgumentChecking()
         {
             var someObservable = Observable.Return(1);
@@ -40,7 +40,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void And2()
         {
             var scheduler = new TestScheduler();
@@ -66,7 +66,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And2Error()
         {
             var ex = new Exception();
@@ -105,7 +105,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And3()
         {
             var scheduler = new TestScheduler();
@@ -131,7 +131,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And3Error()
         {
             var ex = new Exception();
@@ -170,7 +170,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And4()
         {
             var scheduler = new TestScheduler();
@@ -196,7 +196,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And4Error()
         {
             var ex = new Exception();
@@ -236,7 +236,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_LARGEARITY
-        [TestMethod]
+        [Fact]
         public void And5()
         {
             var scheduler = new TestScheduler();
@@ -262,7 +262,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And5Error()
         {
             var ex = new Exception();
@@ -301,7 +301,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And6()
         {
             var scheduler = new TestScheduler();
@@ -327,7 +327,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And6Error()
         {
             var ex = new Exception();
@@ -366,7 +366,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And7()
         {
             var scheduler = new TestScheduler();
@@ -392,7 +392,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And7Error()
         {
             var ex = new Exception();
@@ -431,7 +431,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And8()
         {
             var scheduler = new TestScheduler();
@@ -457,7 +457,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And8Error()
         {
             var ex = new Exception();
@@ -496,7 +496,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And9()
         {
             var scheduler = new TestScheduler();
@@ -522,7 +522,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And9Error()
         {
             var ex = new Exception();
@@ -561,7 +561,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And10()
         {
             var scheduler = new TestScheduler();
@@ -587,7 +587,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And10Error()
         {
             var ex = new Exception();
@@ -626,7 +626,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And11()
         {
             var scheduler = new TestScheduler();
@@ -652,7 +652,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And11Error()
         {
             var ex = new Exception();
@@ -691,7 +691,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And12()
         {
             var scheduler = new TestScheduler();
@@ -717,7 +717,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And12Error()
         {
             var ex = new Exception();
@@ -756,7 +756,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And13()
         {
             var scheduler = new TestScheduler();
@@ -782,7 +782,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And13Error()
         {
             var ex = new Exception();
@@ -821,7 +821,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And14()
         {
             var scheduler = new TestScheduler();
@@ -847,7 +847,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And14Error()
         {
             var ex = new Exception();
@@ -886,7 +886,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And15()
         {
             var scheduler = new TestScheduler();
@@ -912,7 +912,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And15Error()
         {
             var ex = new Exception();
@@ -951,7 +951,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void And16()
         {
             var scheduler = new TestScheduler();
@@ -977,7 +977,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void And16Error()
         {
             var ex = new Exception();
@@ -1021,7 +1021,7 @@ namespace ReactiveTests.Tests
 
         #region Then
 
-        [TestMethod]
+        [Fact]
         public void Then_ArgumentChecking()
         {
             var someObservable = Observable.Return(1);
@@ -1048,7 +1048,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+        [Fact]
         public void Then1()
         {
             var scheduler = new TestScheduler();
@@ -1068,7 +1068,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then1Error()
         {
             var ex = new Exception();
@@ -1088,7 +1088,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then1Throws()
         {
             var ex = new Exception();
@@ -1109,7 +1109,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then2Throws()
         {
             var scheduler = new TestScheduler();
@@ -1135,7 +1135,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then3Throws()
         {
             var scheduler = new TestScheduler();
@@ -1161,7 +1161,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then4Throws()
         {
             var scheduler = new TestScheduler();
@@ -1188,7 +1188,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_LARGEARITY
-        [TestMethod]
+        [Fact]
         public void Then5Throws()
         {
             var scheduler = new TestScheduler();
@@ -1214,7 +1214,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then6Throws()
         {
             var scheduler = new TestScheduler();
@@ -1240,7 +1240,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then7Throws()
         {
             var scheduler = new TestScheduler();
@@ -1266,7 +1266,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then8Throws()
         {
             var scheduler = new TestScheduler();
@@ -1292,7 +1292,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then9Throws()
         {
             var scheduler = new TestScheduler();
@@ -1318,7 +1318,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then10Throws()
         {
             var scheduler = new TestScheduler();
@@ -1344,7 +1344,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then11Throws()
         {
             var scheduler = new TestScheduler();
@@ -1370,7 +1370,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then12Throws()
         {
             var scheduler = new TestScheduler();
@@ -1396,7 +1396,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then13Throws()
         {
             var scheduler = new TestScheduler();
@@ -1422,7 +1422,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then14Throws()
         {
             var scheduler = new TestScheduler();
@@ -1448,7 +1448,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then15Throws()
         {
             var scheduler = new TestScheduler();
@@ -1474,7 +1474,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Then16Throws()
         {
             var scheduler = new TestScheduler();
@@ -1505,14 +1505,14 @@ namespace ReactiveTests.Tests
 
         #region When
 
-        [TestMethod]
+        [Fact]
         public void When_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.When<int>((Plan<int>[])null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.When<int>((IEnumerable<Plan<int>>)null));
         }
 
-        [TestMethod]
+        [Fact]
         public void WhenMultipleDataSymmetric()
         {
             var scheduler = new TestScheduler();
@@ -1545,7 +1545,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void WhenMultipleDataAsymmetric()
         {
             var scheduler = new TestScheduler();
@@ -1576,7 +1576,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void WhenEmptyEmpty()
         {
             var scheduler = new TestScheduler();
@@ -1600,7 +1600,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void WhenNeverNever()
         {
             var scheduler = new TestScheduler();
@@ -1618,7 +1618,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void WhenThrowNonEmpty()
         {
             var ex = new Exception();
@@ -1643,7 +1643,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ComplicatedWhen()
         {
             var scheduler = new TestScheduler();
@@ -1686,14 +1686,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void When_PlansIteratorThrows()
         {
             var ex = new Exception();
             var _e = default(Exception);
 
             GetPlans(ex).When().Subscribe(_ => { }, e => { _e = e; });
-            Assert.AreSame(_e, ex);
+            Assert.Same(_e, ex);
         }
 
         private IEnumerable<Plan<int>> GetPlans(Exception ex)

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableRemotingTest.cs

@@ -8,14 +8,14 @@ using System.Reflection;
 using System.Runtime.Remoting.Lifetime;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableRemotingTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Remotable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => RemotingObservable.Remotable(default(IObservable<int>)));
@@ -100,47 +100,47 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Remotable_Empty()
         {
             var evt = new ManualResetEvent(false);
 
             var e = GetRemoteObservable(t => t.Empty());
-            using (e.Subscribe(_ => { Assert.Fail(); }, _ => { Assert.Fail(); }, () => { evt.Set(); }))
+            using (e.Subscribe(_ => { Assert.True(false); }, _ => { Assert.True(false); }, () => { evt.Set(); }))
             {
                 evt.WaitOne();
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Remotable_Return()
         {
             var evt = new ManualResetEvent(false);
 
             bool next = false;
             var e = GetRemoteObservable(t => t.Return(42));
-            using (e.Subscribe(value => { next = true; Assert.AreEqual(42, value); }, _ => { Assert.Fail(); }, () => { evt.Set(); }))
+            using (e.Subscribe(value => { next = true; Assert.Equal(42, value); }, _ => { Assert.True(false); }, () => { evt.Set(); }))
             {
                 evt.WaitOne();
-                Assert.IsTrue(next);
+                Assert.True(next);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Remotable_Return_LongLease()
         {
             var evt = new ManualResetEvent(false);
 
             bool next = false;
             var e = GetRemoteObservable(t => t.ReturnLongLease(42));
-            using (e.Subscribe(value => { next = true; Assert.AreEqual(42, value); }, _ => { Assert.Fail(); }, () => { evt.Set(); }))
+            using (e.Subscribe(value => { next = true; Assert.Equal(42, value); }, _ => { Assert.True(false); }, () => { evt.Set(); }))
             {
                 evt.WaitOne();
-                Assert.IsTrue(next);
+                Assert.True(next);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Remotable_Throw()
         {
             var ex = new InvalidOperationException("Oops!");
@@ -149,19 +149,19 @@ namespace ReactiveTests.Tests
 
             bool error = false;
             var e = GetRemoteObservable(t => t.Throw(ex));
-            using (e.Subscribe(value => { Assert.Fail(); }, err => { error = true; Assert.IsTrue(err is InvalidOperationException && err.Message == ex.Message); evt.Set(); }, () => { Assert.Fail(); }))
+            using (e.Subscribe(value => { Assert.True(false); }, err => { error = true; Assert.True(err is InvalidOperationException && err.Message == ex.Message); evt.Set(); }, () => { Assert.True(false); }))
             {
                 evt.WaitOne();
-                Assert.IsTrue(error);
+                Assert.True(error);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void Remotable_Disposal()
         {
             var test = GetRemoteTestObject();
             test.Disposal().Subscribe().Dispose();
-            Assert.IsTrue(test.Disposed);
+            Assert.True(test.Disposed);
         }
 
         private IObservable<int> GetRemoteObservable(Func<RemotingTest, IObservable<int>> f)

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/ObservableSafetyTest.cs

@@ -6,21 +6,21 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObservableSafetyTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void SubscribeSafe_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.SubscribeSafe<int>(default(IObservable<int>), Observer.Create<int>(_ => { })));
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.SubscribeSafe<int>(Observable.Return(42), default(IObserver<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Safety_Subscription1()
         {
             var ex = new Exception();
@@ -29,14 +29,14 @@ namespace ReactiveTests.Tests
             var res = xs.Where(x => true).Select(x => x);
 
             var err = default(Exception);
-            var d = res.Subscribe(x => { Assert.Fail(); }, ex_ => { err = ex_; }, () => { Assert.Fail(); });
+            var d = res.Subscribe(x => { Assert.True(false); }, ex_ => { err = ex_; }, () => { Assert.True(false); });
 
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
 
             d.Dispose();
         }
 
-        [TestMethod]
+        [Fact]
         public void Safety_Subscription2()
         {
             var ex = new Exception();
@@ -81,7 +81,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableBase_ObserverThrows()
         {
             var ex = new Exception();
@@ -117,10 +117,10 @@ namespace ReactiveTests.Tests
             disposed.WaitOne();
             failed.WaitOne();
 
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableBase_ObserverThrows_CustomObserver()
         {
             var ex = new Exception();
@@ -153,10 +153,10 @@ namespace ReactiveTests.Tests
             disposed.WaitOne();
             failed.WaitOne();
 
-            Assert.AreSame(ex, err);
+            Assert.Same(ex, err);
         }
 
-        [TestMethod]
+        [Fact]
         public void Producer_ObserverThrows()
         {
             var ex = new Exception();
@@ -189,14 +189,14 @@ namespace ReactiveTests.Tests
             try
             {
                 scheduler.Start();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception err)
             {
-                Assert.AreSame(ex, err);
+                Assert.Same(ex, err);
             }
 
-            Assert.AreEqual(225, scheduler.Clock);
+            Assert.Equal(225, scheduler.Clock);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(200, 225)
@@ -207,7 +207,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Producer_ObserverThrows_CustomObserver()
         {
             var ex = new Exception();
@@ -236,14 +236,14 @@ namespace ReactiveTests.Tests
             try
             {
                 scheduler.Start();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception err)
             {
-                Assert.AreSame(ex, err);
+                Assert.Same(ex, err);
             }
 
-            Assert.AreEqual(225, scheduler.Clock);
+            Assert.Equal(225, scheduler.Clock);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(200, 225)

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/QbservableExTest.cs

@@ -8,18 +8,18 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class QbservableExTest : ReactiveTest
     {
         private IQbservable<int> _qbNull = null;
         private IQbservable<int> _qbMy = new MyQbservable<int>();
         private IQbservableProvider _qbp = new MyQbservableProvider();
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin_ArgumentNullChecks()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbNull, _qbMy, (a, b) => a + b));
@@ -31,7 +31,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbp, default(IQueryable<IObservable<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ForkJoin()
         {
             _qbMy.ForkJoin(_qbMy, (a, b) => a + b);
@@ -39,7 +39,7 @@ namespace ReactiveTests.Tests
             _qbp.ForkJoin(new MyQueryable<IObservable<int>>());
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_ArgumentNullChecks()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Create<int>(default(IQbservableProvider), _ => new IObservable<object>[0]));
@@ -48,21 +48,21 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Create(_qbp, null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Create()
         {
             _qbp.Create<int>(obs => new IObservable<object>[0]);
             _qbp.Create(() => new IObservable<object>[0]);
         }
 
-        [TestMethod]
+        [Fact]
         public void Let_ArgumentNullChecks()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Let(_qbNull, xs => xs));
             ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Let(_qbMy, default(Expression<Func<IObservable<int>, IObservable<int>>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Let()
         {
             _qbMy.Let(xs => xs);

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/Subjects/AsyncSubjectTest.cs

@@ -4,27 +4,28 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Subjects;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class AsyncSubjectTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Subscribe_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new AsyncSubject<int>().Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new AsyncSubject<int>().OnError(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite()
         {
             var scheduler = new TestScheduler();
@@ -81,7 +82,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite()
         {
             var scheduler = new TestScheduler();
@@ -141,7 +142,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error()
         {
             var scheduler = new TestScheduler();
@@ -201,7 +202,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled()
         {
             var scheduler = new TestScheduler();
@@ -252,7 +253,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed()
         {
             var scheduler = new TestScheduler();
@@ -300,22 +301,24 @@ namespace ReactiveTests.Tests
         }
 
 #if HAS_AWAIT
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void Await_Blocking()
         {
             var s = new AsyncSubject<int>();
             GetResult_Blocking(s.GetAwaiter());
         }
 
-        [TestMethod]
+        [Fact]
         public void Await_Throw()
         {
             var s = new AsyncSubject<int>();
             GetResult_Blocking_Throw(s.GetAwaiter());
         }
+#endif
 #endif
 
-        [TestMethod]
+        [Fact]
         public void GetResult_Empty()
         {
             var s = new AsyncSubject<int>();
@@ -323,7 +326,8 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => s.GetResult());
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void GetResult_Blocking()
         {
             GetResult_Blocking(new AsyncSubject<int>());
@@ -331,7 +335,7 @@ namespace ReactiveTests.Tests
 
         private void GetResult_Blocking(AsyncSubject<int> s)
         {
-            Assert.IsFalse(s.IsCompleted);
+            Assert.False(s.IsCompleted);
 
             var e = new ManualResetEvent(false);
 
@@ -347,11 +351,11 @@ namespace ReactiveTests.Tests
             e.Set();
             t.Join();
 
-            Assert.AreEqual(42, y);
-            Assert.IsTrue(s.IsCompleted);
+            Assert.Equal(42, y);
+            Assert.True(s.IsCompleted);
         }
 
-        [TestMethod]
+        [Fact]
         public void GetResult_Blocking_Throw()
         {
             GetResult_Blocking_Throw(new AsyncSubject<int>());
@@ -359,7 +363,7 @@ namespace ReactiveTests.Tests
 
         private void GetResult_Blocking_Throw(AsyncSubject<int> s)
         {
-            Assert.IsFalse(s.IsCompleted);
+            Assert.False(s.IsCompleted);
 
             var e = new ManualResetEvent(false);
 
@@ -387,12 +391,13 @@ namespace ReactiveTests.Tests
             e.Set();
             t.Join();
 
-            Assert.AreSame(ex, y);
-            Assert.IsTrue(s.IsCompleted);
+            Assert.Same(ex, y);
+            Assert.True(s.IsCompleted);
         }
+#endif
 
 #if HAS_AWAIT
-        [TestMethod]
+        [Fact]
         public void GetResult_Context()
         {
             var x = new AsyncSubject<int>();
@@ -400,7 +405,7 @@ namespace ReactiveTests.Tests
             var ctx = new MyContext();
             var e = new ManualResetEvent(false);
 
-            new Thread(() =>
+            Task.Run(() =>
             {
                 SynchronizationContext.SetSynchronizationContext(ctx);
 
@@ -409,14 +414,14 @@ namespace ReactiveTests.Tests
                 {
                     e.Set();
                 });
-            }).Start();
+            });
 
             x.OnNext(42);
             x.OnCompleted();
 
             e.WaitOne();
 
-            Assert.IsTrue(ctx.ran);
+            Assert.True(ctx.ran);
         }
 
         class MyContext : SynchronizationContext
@@ -431,113 +436,113 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void HasObservers()
         {
             var s = new AsyncSubject<int>();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d1 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d1.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d2 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             var d3 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d2.Dispose();
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d3.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose1()
         {
             var s = new AsyncSubject<int>();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose2()
         {
             var s = new AsyncSubject<int>();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose3()
         {
             var s = new AsyncSubject<int>();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnCompleted()
         {
             var s = new AsyncSubject<int>();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnCompleted();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnError()
         {
             var s = new AsyncSubject<int>();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { }, ex => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnError(new Exception());
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/Subjects/BehaviorSubjectTest.cs

@@ -4,26 +4,26 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Subjects;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class BehaviorSubjectTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Subscribe_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new BehaviorSubject<int>(1).Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new BehaviorSubject<int>(1).OnError(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite()
         {
             var scheduler = new TestScheduler();
@@ -90,7 +90,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite()
         {
             var scheduler = new TestScheduler();
@@ -155,7 +155,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error()
         {
             var scheduler = new TestScheduler();
@@ -222,7 +222,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled()
         {
             var scheduler = new TestScheduler();
@@ -275,7 +275,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed()
         {
             var scheduler = new TestScheduler();
@@ -333,206 +333,206 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d1 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d1.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d2 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             var d3 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d2.Dispose();
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d3.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose1()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose2()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose3()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnCompleted()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnCompleted();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnError()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { }, ex => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnError(new Exception());
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_Initial()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.AreEqual(42, s.Value);
+            Assert.Equal(42, s.Value);
 
             var x = default(int);
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(42, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(42, x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_First()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.AreEqual(42, s.Value);
+            Assert.Equal(42, s.Value);
 
             var x = default(int);
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(42, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(42, x);
 
             s.OnNext(43);
-            Assert.AreEqual(43, s.Value);
+            Assert.Equal(43, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(43, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(43, x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_Second()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.AreEqual(42, s.Value);
+            Assert.Equal(42, s.Value);
 
             var x = default(int);
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(42, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(42, x);
 
             s.OnNext(43);
-            Assert.AreEqual(43, s.Value);
+            Assert.Equal(43, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(43, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(43, x);
 
             s.OnNext(44);
-            Assert.AreEqual(44, s.Value);
+            Assert.Equal(44, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(44, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(44, x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_FrozenAfterOnCompleted()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.AreEqual(42, s.Value);
+            Assert.Equal(42, s.Value);
 
             var x = default(int);
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(42, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(42, x);
 
             s.OnNext(43);
-            Assert.AreEqual(43, s.Value);
+            Assert.Equal(43, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(43, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(43, x);
 
             s.OnNext(44);
-            Assert.AreEqual(44, s.Value);
+            Assert.Equal(44, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(44, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(44, x);
 
             s.OnCompleted();
-            Assert.AreEqual(44, s.Value);
+            Assert.Equal(44, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(44, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(44, x);
 
             s.OnNext(1234);
-            Assert.AreEqual(44, s.Value);
+            Assert.Equal(44, s.Value);
 
-            Assert.IsTrue(s.TryGetValue(out x));
-            Assert.AreEqual(44, x);
+            Assert.True(s.TryGetValue(out x));
+            Assert.Equal(44, x);
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_ThrowsAfterOnError()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.AreEqual(42, s.Value);
+            Assert.Equal(42, s.Value);
 
             s.OnError(new InvalidOperationException());
 
@@ -548,11 +548,11 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_ThrowsOnDispose()
         {
             var s = new BehaviorSubject<int>(42);
-            Assert.AreEqual(42, s.Value);
+            Assert.Equal(42, s.Value);
 
             s.Dispose();
 
@@ -562,7 +562,7 @@ namespace ReactiveTests.Tests
             });
 
             var x = default(int);
-            Assert.IsFalse(s.TryGetValue(out x));
+            Assert.False(s.TryGetValue(out x));
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/Subjects/ReplaySubjectTest.cs

@@ -8,7 +8,7 @@ using System.Reactive.Concurrency;
 using System.Reactive.Subjects;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using ReactiveTests.Dummies;
 
 #if !NO_TPL
@@ -17,10 +17,10 @@ using System.Threading.Tasks;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ReplaySubjectTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Subscribe_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ReplaySubject<int>().Subscribe(null));
@@ -29,7 +29,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new ReplaySubject<int>(DummyScheduler.Instance).Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ReplaySubject<int>().OnError(null));
@@ -38,7 +38,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new ReplaySubject<int>(DummyScheduler.Instance).OnError(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Constructor_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new ReplaySubject<int>(-1));
@@ -65,7 +65,7 @@ namespace ReactiveTests.Tests
             new ReplaySubject<int>(0, TimeSpan.Zero, DummyScheduler.Instance);
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite_ReplayByTime()
         {
             var scheduler = new TestScheduler();
@@ -133,7 +133,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite_ReplayOne()
         {
             var scheduler = new TestScheduler();
@@ -208,7 +208,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite_ReplayMany()
         {
             var scheduler = new TestScheduler();
@@ -280,7 +280,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite_ReplayAll()
         {
             var scheduler = new TestScheduler();
@@ -357,7 +357,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite2()
         {
             var scheduler = new TestScheduler();
@@ -428,7 +428,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite_ReplayByTime()
         {
             var scheduler = new TestScheduler();
@@ -493,7 +493,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite_ReplayOne()
         {
             var scheduler = new TestScheduler();
@@ -558,7 +558,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite_ReplayMany()
         {
             var scheduler = new TestScheduler();
@@ -628,7 +628,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite_ReplayAll()
         {
             var scheduler = new TestScheduler();
@@ -700,7 +700,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error_ReplayByTime()
         {
             var scheduler = new TestScheduler();
@@ -768,7 +768,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error_ReplayOne()
         {
             var scheduler = new TestScheduler();
@@ -835,7 +835,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error_ReplayMany()
         {
             var scheduler = new TestScheduler();
@@ -907,7 +907,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error_ReplayAll()
         {
             var scheduler = new TestScheduler();
@@ -981,7 +981,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled_ReplayByTime()
         {
             var scheduler = new TestScheduler();
@@ -1032,7 +1032,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled_ReplayOne()
         {
             var scheduler = new TestScheduler();
@@ -1083,7 +1083,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled_ReplayMany()
         {
             var scheduler = new TestScheduler();
@@ -1134,7 +1134,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled_ReplayAll()
         {
             var scheduler = new TestScheduler();
@@ -1185,7 +1185,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed()
         {
             var scheduler = new TestScheduler();
@@ -1246,7 +1246,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed_ReplayOne()
         {
             var scheduler = new TestScheduler();
@@ -1304,7 +1304,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed_ReplayMany()
         {
             var scheduler = new TestScheduler();
@@ -1365,7 +1365,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed_ReplayAll()
         {
             var scheduler = new TestScheduler();
@@ -1432,7 +1432,7 @@ namespace ReactiveTests.Tests
         // I think it may have to do with calling Trim() on Subscription (as well as in the OnNext calls). -LC
         //
 
-        [TestMethod]
+        [Fact]
         public void ReplaySubjectDiesOut()
         {
             //
@@ -1495,7 +1495,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers()
         {
             HasObservers(new ReplaySubject<int>());
@@ -1506,28 +1506,28 @@ namespace ReactiveTests.Tests
 
         private static void HasObservers(ReplaySubject<int> s)
         {
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d1 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d1.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d2 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             var d3 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d2.Dispose();
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d3.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose1()
         {
             HasObservers_Dispose1(new ReplaySubject<int>());
@@ -1538,23 +1538,23 @@ namespace ReactiveTests.Tests
 
         private static void HasObservers_Dispose1(ReplaySubject<int> s)
         {
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose2()
         {
             HasObservers_Dispose2(new ReplaySubject<int>());
@@ -1565,23 +1565,23 @@ namespace ReactiveTests.Tests
 
         private static void HasObservers_Dispose2(ReplaySubject<int> s)
         {
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose3()
         {
             HasObservers_Dispose3(new ReplaySubject<int>());
@@ -1592,15 +1592,15 @@ namespace ReactiveTests.Tests
 
         private static void HasObservers_Dispose3(ReplaySubject<int> s)
         {
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnCompleted()
         {
             HasObservers_OnCompleted(new ReplaySubject<int>());
@@ -1611,19 +1611,19 @@ namespace ReactiveTests.Tests
 
         private static void HasObservers_OnCompleted(ReplaySubject<int> s)
         {
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnCompleted();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnError()
         {
             HasObservers_OnError(new ReplaySubject<int>());
@@ -1634,19 +1634,19 @@ namespace ReactiveTests.Tests
 
         private static void HasObservers_OnError(ReplaySubject<int> s)
         {
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { }, ex => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnError(new Exception());
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void Completed_to_late_subscriber_ReplayAll()
         {
             var s = new ReplaySubject<int>();
@@ -1658,14 +1658,14 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(3, observer.Messages.Count);
+            Assert.Equal(3, observer.Messages.Count);
 
-            Assert.AreEqual(1, observer.Messages[0].Value.Value);
-            Assert.AreEqual(2, observer.Messages[1].Value.Value);
-            Assert.AreEqual(NotificationKind.OnCompleted, observer.Messages[2].Value.Kind);
+            Assert.Equal(1, observer.Messages[0].Value.Value);
+            Assert.Equal(2, observer.Messages[1].Value.Value);
+            Assert.Equal(NotificationKind.OnCompleted, observer.Messages[2].Value.Kind);
         }
 
-        [TestMethod]
+        [Fact]
         public void Completed_to_late_subscriber_ReplayOne()
         {
             var s = new ReplaySubject<int>(1);
@@ -1677,13 +1677,13 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(2, observer.Messages.Count);
+            Assert.Equal(2, observer.Messages.Count);
 
-            Assert.AreEqual(2, observer.Messages[0].Value.Value);
-            Assert.AreEqual(NotificationKind.OnCompleted, observer.Messages[1].Value.Kind);
+            Assert.Equal(2, observer.Messages[0].Value.Value);
+            Assert.Equal(NotificationKind.OnCompleted, observer.Messages[1].Value.Kind);
         }
 
-        [TestMethod]
+        [Fact]
         public void Completed_to_late_subscriber_ReplayMany()
         {
             var s = new ReplaySubject<int>(2);
@@ -1696,14 +1696,14 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(3, observer.Messages.Count);
+            Assert.Equal(3, observer.Messages.Count);
 
-            Assert.AreEqual(2, observer.Messages[0].Value.Value);
-            Assert.AreEqual(3, observer.Messages[1].Value.Value);
-            Assert.AreEqual(NotificationKind.OnCompleted, observer.Messages[2].Value.Kind);
+            Assert.Equal(2, observer.Messages[0].Value.Value);
+            Assert.Equal(3, observer.Messages[1].Value.Value);
+            Assert.Equal(NotificationKind.OnCompleted, observer.Messages[2].Value.Kind);
         }
 
-        [TestMethod]
+        [Fact]
         public void Completed_to_late_subscriber_ReplayByTime()
         {
             var s = new ReplaySubject<int>(TimeSpan.FromMinutes(1));
@@ -1716,15 +1716,15 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(4, observer.Messages.Count);
+            Assert.Equal(4, observer.Messages.Count);
 
-            Assert.AreEqual(1, observer.Messages[0].Value.Value);
-            Assert.AreEqual(2, observer.Messages[1].Value.Value);
-            Assert.AreEqual(3, observer.Messages[2].Value.Value);
-            Assert.AreEqual(NotificationKind.OnCompleted, observer.Messages[3].Value.Kind);
+            Assert.Equal(1, observer.Messages[0].Value.Value);
+            Assert.Equal(2, observer.Messages[1].Value.Value);
+            Assert.Equal(3, observer.Messages[2].Value.Value);
+            Assert.Equal(NotificationKind.OnCompleted, observer.Messages[3].Value.Kind);
         }
 
-        [TestMethod]
+        [Fact]
         public void Errored_to_late_subscriber_ReplayAll()
         {
             var expectedException = new Exception("Test");
@@ -1737,15 +1737,15 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(3, observer.Messages.Count);
+            Assert.Equal(3, observer.Messages.Count);
 
-            Assert.AreEqual(1, observer.Messages[0].Value.Value);
-            Assert.AreEqual(2, observer.Messages[1].Value.Value);
-            Assert.AreEqual(NotificationKind.OnError, observer.Messages[2].Value.Kind);
-            Assert.AreEqual(expectedException, observer.Messages[2].Value.Exception);
+            Assert.Equal(1, observer.Messages[0].Value.Value);
+            Assert.Equal(2, observer.Messages[1].Value.Value);
+            Assert.Equal(NotificationKind.OnError, observer.Messages[2].Value.Kind);
+            Assert.Equal(expectedException, observer.Messages[2].Value.Exception);
         }
 
-        [TestMethod]
+        [Fact]
         public void Errored_to_late_subscriber_ReplayOne()
         {
             var expectedException = new Exception("Test");
@@ -1758,14 +1758,14 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(2, observer.Messages.Count);
+            Assert.Equal(2, observer.Messages.Count);
 
-            Assert.AreEqual(2, observer.Messages[0].Value.Value);
-            Assert.AreEqual(NotificationKind.OnError, observer.Messages[1].Value.Kind);
-            Assert.AreEqual(expectedException, observer.Messages[1].Value.Exception);
+            Assert.Equal(2, observer.Messages[0].Value.Value);
+            Assert.Equal(NotificationKind.OnError, observer.Messages[1].Value.Kind);
+            Assert.Equal(expectedException, observer.Messages[1].Value.Exception);
         }
 
-        [TestMethod]
+        [Fact]
         public void Errored_to_late_subscriber_ReplayMany()
         {
             var expectedException = new Exception("Test");
@@ -1779,15 +1779,15 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(3, observer.Messages.Count);
+            Assert.Equal(3, observer.Messages.Count);
 
-            Assert.AreEqual(2, observer.Messages[0].Value.Value);
-            Assert.AreEqual(3, observer.Messages[1].Value.Value);
-            Assert.AreEqual(NotificationKind.OnError, observer.Messages[2].Value.Kind);
-            Assert.AreEqual(expectedException, observer.Messages[2].Value.Exception);
+            Assert.Equal(2, observer.Messages[0].Value.Value);
+            Assert.Equal(3, observer.Messages[1].Value.Value);
+            Assert.Equal(NotificationKind.OnError, observer.Messages[2].Value.Kind);
+            Assert.Equal(expectedException, observer.Messages[2].Value.Exception);
         }
 
-        [TestMethod]
+        [Fact]
         public void Errored_to_late_subscriber_ReplayByTime()
         {
             var expectedException = new Exception("Test");
@@ -1801,16 +1801,16 @@ namespace ReactiveTests.Tests
             var observer = scheduler.CreateObserver<int>();
             s.Subscribe(observer);
 
-            Assert.AreEqual(4, observer.Messages.Count);
+            Assert.Equal(4, observer.Messages.Count);
 
-            Assert.AreEqual(1, observer.Messages[0].Value.Value);
-            Assert.AreEqual(2, observer.Messages[1].Value.Value);
-            Assert.AreEqual(3, observer.Messages[2].Value.Value);
-            Assert.AreEqual(NotificationKind.OnError, observer.Messages[3].Value.Kind);
-            Assert.AreEqual(expectedException, observer.Messages[3].Value.Exception);
+            Assert.Equal(1, observer.Messages[0].Value.Value);
+            Assert.Equal(2, observer.Messages[1].Value.Value);
+            Assert.Equal(3, observer.Messages[2].Value.Value);
+            Assert.Equal(NotificationKind.OnError, observer.Messages[3].Value.Kind);
+            Assert.Equal(expectedException, observer.Messages[3].Value.Exception);
         }
 
-        [TestMethod]
+        [Fact]
         public void ReplaySubject_Reentrant()
         {
             var r = new ReplaySubject<int>(4);
@@ -1836,7 +1836,7 @@ namespace ReactiveTests.Tests
 
             r.OnNext(5);
 
-            Assert.IsTrue(xs.SequenceEqual(new[]
+            Assert.True(xs.SequenceEqual(new[]
             {
                 1, 2, 3, 4, // original
                 1, 2, 3, 4, // reentrant (+ fed back)
@@ -1847,7 +1847,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_INTERNALSTEST
-        [TestMethod]
+        [Fact]
         public void FastImmediateObserver_Simple1()
         {
             var res = FastImmediateObserverTest(fio =>
@@ -1868,7 +1868,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FastImmediateObserver_Simple2()
         {
             var ex = new Exception();
@@ -1891,7 +1891,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FastImmediateObserver_Simple3()
         {
             var res = FastImmediateObserverTest(fio =>
@@ -1917,7 +1917,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void FastImmediateObserver_Fault()
         {
             var xs = new List<int>();
@@ -1942,11 +1942,11 @@ namespace ReactiveTests.Tests
             fio.OnNext(2);
             fio.EnsureActive();
 
-            Assert.IsTrue(xs.Count == 2);
+            Assert.True(xs.Count == 2);
         }
 
 #if !NO_TPL
-        [TestMethod]
+        [Fact]
         public void FastImmediateObserver_Ownership1()
         {
             var xs = new List<int>();
@@ -1979,10 +1979,10 @@ namespace ReactiveTests.Tests
 
             Task.WaitAll(ts);
 
-            Assert.IsTrue(xs.Count == ts.Length * N);
+            Assert.True(xs.Count == ts.Length * N);
         }
 
-        [TestMethod]
+        [Fact]
         public void FastImmediateObserver_Ownership2()
         {
             var cd = new CountdownEvent(3);
@@ -2018,7 +2018,7 @@ namespace ReactiveTests.Tests
 
             cd.Wait();
 
-            Assert.IsTrue(xs.Count == 3);
+            Assert.True(xs.Count == 3);
         }
 #endif
 

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/Subjects/SubjectTest.cs

@@ -8,26 +8,26 @@ using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class SubjectTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Subscribe_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new Subject<int>().Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new Subject<int>().OnError(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Infinite()
         {
             var scheduler = new TestScheduler();
@@ -91,7 +91,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Finite()
         {
             var scheduler = new TestScheduler();
@@ -154,7 +154,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Error()
         {
             var scheduler = new TestScheduler();
@@ -219,7 +219,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Canceled()
         {
             var scheduler = new TestScheduler();
@@ -270,7 +270,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Dispose()
         {
             var scheduler = new TestScheduler();
@@ -291,7 +291,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void PreComplete()
         {
             var scheduler = new TestScheduler();
@@ -307,7 +307,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void SubjectDisposed()
         {
             var scheduler = new TestScheduler();
@@ -362,7 +362,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subject_Create_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Create<int, int>(null, Observable.Return(42)));
@@ -372,7 +372,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Create<int>(Observer.Create<int>(x => { }), null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Subject_Create1()
         {
             var _x = default(int);
@@ -386,21 +386,21 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Subscribe(null));
             s.Subscribe(x => _x = x);
-            Assert.AreEqual(42, _x);
+            Assert.Equal(42, _x);
 
             s.OnNext(21);
-            Assert.AreEqual(21, _x);
+            Assert.Equal(21, _x);
 
             ReactiveAssert.Throws<ArgumentNullException>(() => s.OnError(null));
             var e = new Exception();
             s.OnError(e);
-            Assert.AreSame(e, _ex);
+            Assert.Same(e, _ex);
 
             s.OnCompleted();
-            Assert.IsFalse(done); // already cut off
+            Assert.False(done); // already cut off
         }
 
-        [TestMethod]
+        [Fact]
         public void Subject_Create2()
         {
             var _x = default(int);
@@ -414,21 +414,21 @@ namespace ReactiveTests.Tests
 
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Subscribe(null));
             s.Subscribe(x => _x = x);
-            Assert.AreEqual(42, _x);
+            Assert.Equal(42, _x);
 
             s.OnNext(21);
-            Assert.AreEqual(21, _x);
+            Assert.Equal(21, _x);
 
             ReactiveAssert.Throws<ArgumentNullException>(() => s.OnError(null));
             var e = new Exception();
             s.OnError(e);
-            Assert.AreSame(e, _ex);
+            Assert.Same(e, _ex);
 
             s.OnCompleted();
-            Assert.IsFalse(done); // already cut off
+            Assert.False(done); // already cut off
         }
 
-        [TestMethod]
+        [Fact]
         public void Subject_Synchronize_ArgumentChecking()
         {
             var s = new Subject<int>();
@@ -442,7 +442,8 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Synchronize(s, null));
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void Subject_Synchronize1()
         {
             var N = 10;
@@ -462,10 +463,10 @@ namespace ReactiveTests.Tests
             foreach (var u in t)
                 u.Join();
 
-            Assert.AreEqual(Enumerable.Range(0, N).Sum(), y);
+            Assert.Equal(Enumerable.Range(0, N).Sum(), y);
         }
-
-        [TestMethod]
+        
+        [Fact]
         public void Subject_Synchronize2()
         {
             var N = 10;
@@ -486,116 +487,117 @@ namespace ReactiveTests.Tests
             foreach (var u in t)
                 u.Join();
 
-            Assert.AreEqual(Enumerable.Range(0, N).Sum(), y);
+            Assert.Equal(Enumerable.Range(0, N).Sum(), y);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void HasObservers()
         {
             var s = new Subject<int>();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d1 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d1.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d2 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             var d3 = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d2.Dispose();
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             d3.Dispose();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose1()
         {
             var s = new Subject<int>();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose2()
         {
             var s = new Subject<int>();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.True(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             d.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_Dispose3()
         {
             var s = new Subject<int>();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsFalse(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.False(s.IsDisposed);
 
             s.Dispose();
-            Assert.IsFalse(s.HasObservers);
-            Assert.IsTrue(s.IsDisposed);
+            Assert.False(s.HasObservers);
+            Assert.True(s.IsDisposed);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnCompleted()
         {
             var s = new Subject<int>();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnCompleted();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
 
-        [TestMethod]
+        [Fact]
         public void HasObservers_OnError()
         {
             var s = new Subject<int>();
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
 
             var d = s.Subscribe(_ => { }, ex => { });
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnNext(42);
-            Assert.IsTrue(s.HasObservers);
+            Assert.True(s.HasObservers);
 
             s.OnError(new Exception());
-            Assert.IsFalse(s.HasObservers);
+            Assert.False(s.HasObservers);
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/ListObservableTest.cs

@@ -7,61 +7,61 @@ using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ListObservableTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void Ctor_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ListObservable<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ListObservable<int>(Observable.Never<int>()).Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_None()
         {
             var o = new ListObservable<int>(Observable.Empty<int>());
             ReactiveAssert.Throws<InvalidOperationException>(() => { var t = o.Value; });
         }
 
-        [TestMethod]
+        [Fact]
         public void Value_Some()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(9, o.Value);
+            Assert.Equal(9, o.Value);
         }
 
-        [TestMethod]
+        [Fact]
         public void IndexOf_None()
         {
             var o = new ListObservable<int>(Observable.Empty<int>());
-            Assert.AreEqual(-1, o.IndexOf(0));
+            Assert.Equal(-1, o.IndexOf(0));
         }
 
-        [TestMethod]
+        [Fact]
         public void IndexOf_Some_NotFound()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(-1, o.IndexOf(100));
+            Assert.Equal(-1, o.IndexOf(100));
         }
 
-        [TestMethod]
+        [Fact]
         public void IndexOf_Some_Found()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(3, o.IndexOf(3));
+            Assert.Equal(3, o.IndexOf(3));
         }
 
-        [TestMethod]
+        [Fact]
         public void RemoveAt_Some_NotFound()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -69,7 +69,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void RemoveAt_Some_Found()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -77,7 +77,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Insert_Invalid()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -85,7 +85,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Insert_Invalid_2()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -93,7 +93,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Insert_Beginning()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -101,7 +101,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Insert_Middle()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -109,7 +109,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, -1, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Change_Beginning()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -117,7 +117,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(-1, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Change_Middle()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -125,7 +125,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 3, 4, -1, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Change_End()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -133,14 +133,14 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, -1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Change_Error()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => o[100] = -1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Insert_End()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -148,28 +148,28 @@ namespace ReactiveTests.Tests
             o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1);
         }
 
-        [TestMethod]
+        [Fact]
         public void Contains_None()
         {
             var o = new ListObservable<int>(Observable.Empty<int>());
-            Assert.AreEqual(false, o.Contains(0));
+            Assert.Equal(false, o.Contains(0));
         }
 
-        [TestMethod]
+        [Fact]
         public void Contains_Some_NotFound()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(false, o.Contains(100));
+            Assert.Equal(false, o.Contains(100));
         }
 
-        [TestMethod]
+        [Fact]
         public void Contains_Some_Found()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(true, o.Contains(3));
+            Assert.Equal(true, o.Contains(3));
         }
 
-        [TestMethod]
+        [Fact]
         public void Clear()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -177,35 +177,35 @@ namespace ReactiveTests.Tests
             o.AssertEqual();
         }
 
-        [TestMethod]
+        [Fact]
         public void IsReadOnly()
         {
             var o = new ListObservable<int>(Observable.Never<int>());
-            Assert.AreEqual(false, o.IsReadOnly);
+            Assert.Equal(false, o.IsReadOnly);
         }
 
-        [TestMethod]
+        [Fact]
         public void This_None()
         {
             var o = new ListObservable<int>(Observable.Empty<int>());
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => { var t = o[0]; });
         }
 
-        [TestMethod]
+        [Fact]
         public void This_Some_NotFound()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => { var t = o[100]; });
         }
 
-        [TestMethod]
+        [Fact]
         public void This_Some_Found()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(5, o[5]);
+            Assert.Equal(5, o[5]);
         }
 
-        [TestMethod]
+        [Fact]
         public void CopyTo_RightSize()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -214,7 +214,7 @@ namespace ReactiveTests.Tests
             array.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void CopyTo_RightSize_Offset()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -222,7 +222,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentException>(() => o.CopyTo(array, 3));
         }
 
-        [TestMethod]
+        [Fact]
         public void CopyTo_Bigger()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -231,7 +231,7 @@ namespace ReactiveTests.Tests
             array.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0);
         }
 
-        [TestMethod]
+        [Fact]
         public void CopyTo_Bigger_Offset()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -240,7 +240,7 @@ namespace ReactiveTests.Tests
             array.AssertEqual(0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0);
         }
 
-        [TestMethod]
+        [Fact]
         public void CopyTo_Smaller()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -248,7 +248,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentException>(() => o.CopyTo(array, 0));
         }
 
-        [TestMethod]
+        [Fact]
         public void CopyTo_Smaller_Offset()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -256,7 +256,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentException>(() => o.CopyTo(array, 3));
         }
 
-        [TestMethod]
+        [Fact]
         public void Add_Empty()
         {
             var o = new ListObservable<int>(Observable.Empty<int>());
@@ -264,7 +264,7 @@ namespace ReactiveTests.Tests
             o.AssertEqual(100);
         }
 
-        [TestMethod]
+        [Fact]
         public void Add_Some()
         {
             var o = new ListObservable<int>(Observable.Return(200));
@@ -272,31 +272,31 @@ namespace ReactiveTests.Tests
             o.AssertEqual(200, 100);
         }
 
-        [TestMethod]
+        [Fact]
         public void Remove_None()
         {
             var o = new ListObservable<int>(Observable.Empty<int>());
-            Assert.AreEqual(false, o.Remove(0));
+            Assert.Equal(false, o.Remove(0));
             o.AssertEqual();
         }
 
-        [TestMethod]
+        [Fact]
         public void Remove_Some_NotFound()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(false, o.Remove(100));
+            Assert.Equal(false, o.Remove(100));
             o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Remove_Some_Found()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
-            Assert.AreEqual(true, o.Remove(3));
+            Assert.Equal(true, o.Remove(3));
             o.AssertEqual(0, 1, 2, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEach()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -308,7 +308,7 @@ namespace ReactiveTests.Tests
             l.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void ForEach_Old()
         {
             var o = new ListObservable<int>(Observable.Range(0, 10));
@@ -320,7 +320,7 @@ namespace ReactiveTests.Tests
             l.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_Never()
         {
             var s = new TestScheduler();
@@ -334,7 +334,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_Infinite()
         {
             var s = new TestScheduler();
@@ -349,7 +349,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_Error()
         {
             var s = new TestScheduler();
@@ -368,7 +368,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_Completed()
         {
             var s = new TestScheduler();
@@ -385,7 +385,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_Disposed()
         {
             var s = new TestScheduler();
@@ -401,7 +401,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Subscribe_Disposed_Multi()
         {
             var s = new TestScheduler();

Rx.NET/Source/Tests.System.Reactive/Tests/NotificationTest.cs

@@ -4,22 +4,22 @@ using System;
 using System.Reactive;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class NotificationTest : ReactiveTest
     {
         #region ToObservable
 
-        [TestMethod]
+        [Fact]
         public void ToObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Notification.CreateOnNext<int>(1).ToObservable(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable_Empty()
         {
             var scheduler = new TestScheduler();
@@ -33,7 +33,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable_Return()
         {
             var scheduler = new TestScheduler();
@@ -48,7 +48,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable_Throw()
         {
             var ex = new Exception();
@@ -64,7 +64,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObservable_CurrentThread()
         {
             var evt = new ManualResetEvent(false);
@@ -79,7 +79,7 @@ namespace ReactiveTests.Tests
 
         #endregion
 
-        [TestMethod]
+        [Fact]
         public void Notifications_Equality()
         {
             var n = Notification.CreateOnNext(42);
@@ -90,26 +90,26 @@ namespace ReactiveTests.Tests
             var e1 = e; var e2 = e;
             var c1 = c; var c2 = c;
 
-            Assert.IsTrue(n1 == n2);
-            Assert.IsTrue(e1 == e2);
-            Assert.IsTrue(c1 == c2);
+            Assert.True(n1 == n2);
+            Assert.True(e1 == e2);
+            Assert.True(c1 == c2);
 
-            Assert.IsTrue(n1.Equals(n2));
-            Assert.IsTrue(e1.Equals(e2));
-            Assert.IsTrue(c1.Equals(c2));
+            Assert.True(n1.Equals(n2));
+            Assert.True(e1.Equals(e2));
+            Assert.True(c1.Equals(c2));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_CtorAndProps()
         {
             var n = Notification.CreateOnNext<int>(42);
-            Assert.AreEqual(NotificationKind.OnNext, n.Kind);
-            Assert.IsTrue(n.HasValue);
-            Assert.AreEqual(42, n.Value);
-            Assert.IsNull(n.Exception);
+            Assert.Equal(NotificationKind.OnNext, n.Kind);
+            Assert.True(n.HasValue);
+            Assert.Equal(42, n.Value);
+            Assert.Null(n.Exception);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_Equality()
         {
             var n1 = Notification.CreateOnNext<int>(42);
@@ -117,54 +117,54 @@ namespace ReactiveTests.Tests
             var n3 = Notification.CreateOnNext<int>(24);
             var n4 = Notification.CreateOnCompleted<int>();
 
-            Assert.IsTrue(n1.Equals(n1));
-            Assert.IsTrue(n1.Equals(n2));
-            Assert.IsTrue(n2.Equals(n1));
+            Assert.True(n1.Equals(n1));
+            Assert.True(n1.Equals(n2));
+            Assert.True(n2.Equals(n1));
 
-            Assert.IsFalse(n1.Equals(null));
-            Assert.IsFalse(n1.Equals(""));
+            Assert.False(n1.Equals(null));
+            Assert.False(n1.Equals(""));
 
-            Assert.IsFalse(n1.Equals(n3));
-            Assert.IsFalse(n3.Equals(n1));
-            Assert.IsFalse(n1.Equals(n4));
-            Assert.IsFalse(n4.Equals(n1));
+            Assert.False(n1.Equals(n3));
+            Assert.False(n3.Equals(n1));
+            Assert.False(n1.Equals(n4));
+            Assert.False(n4.Equals(n1));
 
-            Assert.IsTrue(n1 == n2);
-            Assert.IsTrue(n2 == n1);
-            Assert.IsFalse(n1 == null);
-            Assert.IsFalse(null == n1);
-            Assert.IsTrue(!(n1 != n2));
-            Assert.IsTrue(!(n2 != n1));
-            Assert.IsFalse(!(n1 != null));
-            Assert.IsFalse(!(null != n1));
+            Assert.True(n1 == n2);
+            Assert.True(n2 == n1);
+            Assert.False(n1 == null);
+            Assert.False(null == n1);
+            Assert.True(!(n1 != n2));
+            Assert.True(!(n2 != n1));
+            Assert.False(!(n1 != null));
+            Assert.False(!(null != n1));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_GetHashCode()
         {
             var n1 = Notification.CreateOnNext<int>(42);
             var n2 = Notification.CreateOnNext<int>(42);
 
-            Assert.AreNotEqual(0, n1.GetHashCode());
-            Assert.AreEqual(n1.GetHashCode(), n2.GetHashCode());
+            Assert.NotEqual(0, n1.GetHashCode());
+            Assert.Equal(n1.GetHashCode(), n2.GetHashCode());
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_ToString()
         {
             var n1 = Notification.CreateOnNext<int>(42);
-            Assert.IsTrue(n1.ToString().Contains("OnNext"));
-            Assert.IsTrue(n1.ToString().Contains(42.ToString()));
+            Assert.True(n1.ToString().Contains("OnNext"));
+            Assert.True(n1.ToString().Contains(42.ToString()));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_AcceptObserver()
         {
             var con = new CheckOnNextObserver();
             var n1 = Notification.CreateOnNext<int>(42);
             n1.Accept(con);
 
-            Assert.AreEqual(42, con.Value);
+            Assert.Equal(42, con.Value);
         }
 
         class CheckOnNextObserver : IObserver<int>
@@ -187,34 +187,34 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_AcceptObserverWithResult()
         {
             var n1 = Notification.CreateOnNext<int>(42);
-            var res = n1.Accept(new AcceptObserver(x => "OK", _ => { Assert.Fail(); return null; }, () => { Assert.Fail(); return null; }));
+            var res = n1.Accept(new AcceptObserver(x => "OK", _ => { Assert.True(false); return null; }, () => { Assert.True(false); return null; }));
 
-            Assert.AreEqual("OK", res);
+            Assert.Equal("OK", res);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_AcceptObserverWithResult_Null()
         {
             var n1 = Notification.CreateOnNext<int>(42);
             ReactiveAssert.Throws<ArgumentNullException>(() => n1.Accept(default(IObserver<int, string>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_AcceptAction()
         {
             var obs = false;
 
             var n1 = Notification.CreateOnNext<int>(42);
-            n1.Accept(x => { obs = true; }, _ => { Assert.Fail(); }, () => { Assert.Fail(); });
+            n1.Accept(x => { obs = true; }, _ => { Assert.True(false); }, () => { Assert.True(false); });
 
-            Assert.IsTrue(obs);
+            Assert.True(obs);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_Accept_ArgumentChecking()
         {
             var n = Notification.CreateOnNext<int>(42);
@@ -230,22 +230,22 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => n.Accept<string>(x => "", ex => "", default(Func<string>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnNext_AcceptActionWithResult()
         {
             var n1 = Notification.CreateOnNext<int>(42);
-            var res = n1.Accept(x => "OK", _ => { Assert.Fail(); return null; }, () => { Assert.Fail(); return null; });
+            var res = n1.Accept(x => "OK", _ => { Assert.True(false); return null; }, () => { Assert.True(false); return null; });
 
-            Assert.AreEqual("OK", res);
+            Assert.Equal("OK", res);
         }
 
-        [TestMethod, ExpectedException(typeof(ArgumentNullException))]
+        [Fact]
         public void OnError_CtorNull()
         {
-            Notification.CreateOnError<int>(null);
+            ReactiveAssert.Throws<ArgumentNullException>(() => Notification.CreateOnError<int>(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_Accept_ArgumentChecking()
         {
             var n = Notification.CreateOnError<int>(new Exception());
@@ -261,27 +261,27 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => n.Accept<string>(x => "", ex => "", default(Func<string>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_CtorAndProps()
         {
             var e = new Exception();
             var n = Notification.CreateOnError<int>(e);
-            Assert.AreEqual(NotificationKind.OnError, n.Kind);
-            Assert.IsFalse(n.HasValue);
-            Assert.AreSame(e, n.Exception);
+            Assert.Equal(NotificationKind.OnError, n.Kind);
+            Assert.False(n.HasValue);
+            Assert.Same(e, n.Exception);
 
             try
             {
                 var x = n.Value;
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception _e)
             {
-                Assert.AreSame(e, _e);
+                Assert.Same(e, _e);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_Equality()
         {
             var ex1 = new Exception();
@@ -292,29 +292,29 @@ namespace ReactiveTests.Tests
             var n3 = Notification.CreateOnError<int>(ex2);
             var n4 = Notification.CreateOnCompleted<int>();
 
-            Assert.IsTrue(n1.Equals(n1));
-            Assert.IsTrue(n1.Equals(n2));
-            Assert.IsTrue(n2.Equals(n1));
+            Assert.True(n1.Equals(n1));
+            Assert.True(n1.Equals(n2));
+            Assert.True(n2.Equals(n1));
 
-            Assert.IsFalse(n1.Equals(null));
-            Assert.IsFalse(n1.Equals(""));
+            Assert.False(n1.Equals(null));
+            Assert.False(n1.Equals(""));
 
-            Assert.IsFalse(n1.Equals(n3));
-            Assert.IsFalse(n3.Equals(n1));
-            Assert.IsFalse(n1.Equals(n4));
-            Assert.IsFalse(n4.Equals(n1));
+            Assert.False(n1.Equals(n3));
+            Assert.False(n3.Equals(n1));
+            Assert.False(n1.Equals(n4));
+            Assert.False(n4.Equals(n1));
 
-            Assert.IsTrue(n1 == n2);
-            Assert.IsTrue(n2 == n1);
-            Assert.IsFalse(n1 == null);
-            Assert.IsFalse(null == n1);
-            Assert.IsTrue(!(n1 != n2));
-            Assert.IsTrue(!(n2 != n1));
-            Assert.IsFalse(!(n1 != null));
-            Assert.IsFalse(!(null != n1));
+            Assert.True(n1 == n2);
+            Assert.True(n2 == n1);
+            Assert.False(n1 == null);
+            Assert.False(null == n1);
+            Assert.True(!(n1 != n2));
+            Assert.True(!(n2 != n1));
+            Assert.False(!(n1 != null));
+            Assert.False(!(null != n1));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_GetHashCode()
         {
             var ex = new Exception();
@@ -322,21 +322,21 @@ namespace ReactiveTests.Tests
             var n1 = Notification.CreateOnError<int>(ex);
             var n2 = Notification.CreateOnError<int>(ex);
 
-            Assert.AreNotEqual(0, n1.GetHashCode());
-            Assert.AreEqual(n1.GetHashCode(), n2.GetHashCode());
+            Assert.NotEqual(0, n1.GetHashCode());
+            Assert.Equal(n1.GetHashCode(), n2.GetHashCode());
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_ToString()
         {
             var ex = new Exception();
 
             var n1 = Notification.CreateOnError<int>(ex);
-            Assert.IsTrue(n1.ToString().Contains("OnError"));
-            Assert.IsTrue(n1.ToString().Contains(ex.GetType().Name)); // CHECK, no message?
+            Assert.True(n1.ToString().Contains("OnError"));
+            Assert.True(n1.ToString().Contains(ex.GetType().Name)); // CHECK, no message?
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_AcceptObserver()
         {
             var ex = new Exception();
@@ -346,7 +346,7 @@ namespace ReactiveTests.Tests
             var n1 = Notification.CreateOnError<int>(ex);
             n1.Accept(obs);
 
-            Assert.AreSame(ex, obs.Error);
+            Assert.Same(ex, obs.Error);
         }
 
         class CheckOnErrorObserver : IObserver<int>
@@ -369,25 +369,25 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_AcceptObserverWithResult()
         {
             var ex = new Exception();
 
             var n1 = Notification.CreateOnError<int>(ex);
-            var res = n1.Accept(new AcceptObserver(x => { Assert.Fail(); return null; }, _ => { Assert.AreSame(ex, _); return "OK"; }, () => { Assert.Fail(); return null; }));
+            var res = n1.Accept(new AcceptObserver(x => { Assert.True(false); return null; }, _ => { Assert.Same(ex, _); return "OK"; }, () => { Assert.True(false); return null; }));
 
-            Assert.AreEqual("OK", res);
+            Assert.Equal("OK", res);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_AcceptObserverWithResult_Null()
         {
             var n1 = Notification.CreateOnError<int>(new Exception());
             ReactiveAssert.Throws<ArgumentNullException>(() => n1.Accept(default(IObserver<int, string>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_AcceptAction()
         {
             var ex = new Exception();
@@ -395,45 +395,45 @@ namespace ReactiveTests.Tests
             var obs = false;
 
             var n1 = Notification.CreateOnError<int>(ex);
-            n1.Accept(x => { Assert.Fail(); }, _ => { obs = true; }, () => { Assert.Fail(); });
+            n1.Accept(x => { Assert.True(false); }, _ => { obs = true; }, () => { Assert.True(false); });
 
-            Assert.IsTrue(obs);
+            Assert.True(obs);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnError_AcceptActionWithResult()
         {
             var ex = new Exception();
 
             var n1 = Notification.CreateOnError<int>(ex);
-            var res = n1.Accept(x => { Assert.Fail(); return null; }, x => "OK", () => { Assert.Fail(); return null; });
+            var res = n1.Accept(x => { Assert.True(false); return null; }, x => "OK", () => { Assert.True(false); return null; });
 
-            Assert.AreEqual("OK", res);
+            Assert.Equal("OK", res);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_CtorAndProps()
         {
             var n = Notification.CreateOnCompleted<int>();
-            Assert.AreEqual(NotificationKind.OnCompleted, n.Kind);
-            Assert.IsFalse(n.HasValue);
-            Assert.IsNull(n.Exception);
+            Assert.Equal(NotificationKind.OnCompleted, n.Kind);
+            Assert.False(n.HasValue);
+            Assert.Null(n.Exception);
 
             var ok = false;
             try
             {
                 var x = n.Value;
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (InvalidOperationException)
             {
                 ok = true;
             }
 
-            Assert.IsTrue(ok);
+            Assert.True(ok);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_Accept_ArgumentChecking()
         {
             var n = Notification.CreateOnCompleted<int>();
@@ -449,51 +449,51 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => n.Accept<string>(x => "", ex => "", default(Func<string>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_Equality()
         {
             var n1 = Notification.CreateOnCompleted<int>();
             var n2 = Notification.CreateOnCompleted<int>();
             var n3 = Notification.CreateOnNext<int>(2);
 
-            Assert.IsTrue(n1.Equals(n1));
-            Assert.IsTrue(n1.Equals(n2));
-            Assert.IsTrue(n2.Equals(n1));
+            Assert.True(n1.Equals(n1));
+            Assert.True(n1.Equals(n2));
+            Assert.True(n2.Equals(n1));
 
-            Assert.IsFalse(n1.Equals(null));
-            Assert.IsFalse(n1.Equals(""));
+            Assert.False(n1.Equals(null));
+            Assert.False(n1.Equals(""));
 
-            Assert.IsFalse(n1.Equals(n3));
-            Assert.IsFalse(n3.Equals(n1));
+            Assert.False(n1.Equals(n3));
+            Assert.False(n3.Equals(n1));
 
-            Assert.IsTrue(n1 == n2);
-            Assert.IsTrue(n2 == n1);
-            Assert.IsFalse(n1 == null);
-            Assert.IsFalse(null == n1);
-            Assert.IsTrue(!(n1 != n2));
-            Assert.IsTrue(!(n2 != n1));
-            Assert.IsFalse(!(n1 != null));
-            Assert.IsFalse(!(null != n1));
+            Assert.True(n1 == n2);
+            Assert.True(n2 == n1);
+            Assert.False(n1 == null);
+            Assert.False(null == n1);
+            Assert.True(!(n1 != n2));
+            Assert.True(!(n2 != n1));
+            Assert.False(!(n1 != null));
+            Assert.False(!(null != n1));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_GetHashCode()
         {
             var n1 = Notification.CreateOnCompleted<int>();
             var n2 = Notification.CreateOnCompleted<int>();
 
-            Assert.AreNotEqual(0, n1.GetHashCode());
-            Assert.AreEqual(n1.GetHashCode(), n2.GetHashCode());
+            Assert.NotEqual(0, n1.GetHashCode());
+            Assert.Equal(n1.GetHashCode(), n2.GetHashCode());
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_ToString()
         {
             var n1 = Notification.CreateOnCompleted<int>();
-            Assert.IsTrue(n1.ToString().Contains("OnCompleted"));
+            Assert.True(n1.ToString().Contains("OnCompleted"));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_AcceptObserver()
         {
             var obs = new CheckOnCompletedObserver();
@@ -501,7 +501,7 @@ namespace ReactiveTests.Tests
             var n1 = Notification.CreateOnCompleted<int>();
             n1.Accept(obs);
 
-            Assert.IsTrue(obs.Completed);
+            Assert.True(obs.Completed);
         }
 
         class CheckOnCompletedObserver : IObserver<int>
@@ -524,40 +524,40 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_AcceptObserverWithResult()
         {
             var n1 = Notification.CreateOnCompleted<int>();
-            var res = n1.Accept(new AcceptObserver(x => { Assert.Fail(); return null; }, _ => { Assert.Fail(); return null; }, () => "OK"));
+            var res = n1.Accept(new AcceptObserver(x => { Assert.True(false); return null; }, _ => { Assert.True(false); return null; }, () => "OK"));
 
-            Assert.AreEqual("OK", res);
+            Assert.Equal("OK", res);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_AcceptObserverWithResult_Null()
         {
             var n1 = Notification.CreateOnCompleted<int>();
             ReactiveAssert.Throws<ArgumentNullException>(() => n1.Accept(default(IObserver<int, string>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_AcceptAction()
         {
             var obs = false;
 
             var n1 = Notification.CreateOnCompleted<int>();
-            n1.Accept(x => { Assert.Fail(); }, _ => { Assert.Fail(); }, () => { obs = true; });
+            n1.Accept(x => { Assert.True(false); }, _ => { Assert.True(false); }, () => { obs = true; });
 
-            Assert.IsTrue(obs);
+            Assert.True(obs);
         }
 
-        [TestMethod]
+        [Fact]
         public void OnCompleted_AcceptActionWithResult()
         {
             var n1 = Notification.CreateOnCompleted<int>();
-            var res = n1.Accept(x => { Assert.Fail(); return null; }, _ => { Assert.Fail(); return null; }, () => "OK");
+            var res = n1.Accept(x => { Assert.True(false); return null; }, _ => { Assert.True(false); return null; }, () => "OK");
 
-            Assert.AreEqual("OK", res);
+            Assert.Equal("OK", res);
         }
 
         class AcceptObserver : IObserver<int, string>

Rx.NET/Source/Tests.System.Reactive/Tests/ObserverTest.cs

@@ -6,88 +6,89 @@ using System.Linq;
 using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class ObserverTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void ToObserver_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.ToObserver<int>(default(Action<Notification<int>>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObserver_NotificationOnNext()
         {
             int i = 0;
             Action<Notification<int>> next = n =>
             {
-                Assert.AreEqual(i++, 0);
-                Assert.AreEqual(n.Kind, NotificationKind.OnNext);
-                Assert.AreEqual(n.Value, 42);
-                Assert.AreEqual(n.Exception, null);
-                Assert.IsTrue(n.HasValue);
+                Assert.Equal(i++, 0);
+                Assert.Equal(n.Kind, NotificationKind.OnNext);
+                Assert.Equal(n.Value, 42);
+                Assert.Equal(n.Exception, null);
+                Assert.True(n.HasValue);
             };
             next.ToObserver().OnNext(42);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObserver_NotificationOnError()
         {
             var ex = new Exception();
             int i = 0;
             Action<Notification<int>> next = n =>
             {
-                Assert.AreEqual(i++, 0);
-                Assert.AreEqual(n.Kind, NotificationKind.OnError);
-                Assert.AreSame(n.Exception, ex);
-                Assert.IsFalse(n.HasValue);
+                Assert.Equal(i++, 0);
+                Assert.Equal(n.Kind, NotificationKind.OnError);
+                Assert.Same(n.Exception, ex);
+                Assert.False(n.HasValue);
             };
             next.ToObserver().OnError(ex);
         }
 
-        [TestMethod]
+        [Fact]
         public void ToObserver_NotificationOnCompleted()
         {
             var ex = new Exception();
             int i = 0;
             Action<Notification<int>> next = n =>
             {
-                Assert.AreEqual(i++, 0);
-                Assert.AreEqual(n.Kind, NotificationKind.OnCompleted);
-                Assert.IsFalse(n.HasValue);
+                Assert.Equal(i++, 0);
+                Assert.Equal(n.Kind, NotificationKind.OnCompleted);
+                Assert.False(n.HasValue);
             };
             next.ToObserver().OnCompleted();
         }
 
-        [TestMethod]
+        [Fact]
         public void ToNotifier_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.ToNotifier<int>(default(IObserver<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void ToNotifier_Forwards()
         {
             var obsn = new MyObserver();
             obsn.ToNotifier()(Notification.CreateOnNext<int>(42));
-            Assert.AreEqual(obsn.HasOnNext, 42);
+            Assert.Equal(obsn.HasOnNext, 42);
 
             var ex = new Exception();
             var obse = new MyObserver();
             obse.ToNotifier()(Notification.CreateOnError<int>(ex));
-            Assert.AreSame(ex, obse.HasOnError);
+            Assert.Same(ex, obse.HasOnError);
 
             var obsc = new MyObserver();
             obsc.ToNotifier()(Notification.CreateOnCompleted<int>());
-            Assert.IsTrue(obsc.HasOnCompleted);
+            Assert.True(obsc.HasOnCompleted);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.Create<int>(default(Action<int>)));
@@ -100,53 +101,53 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.Create<int>(_ => { }, (Exception _) => { }, default(Action)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNext()
         {
             bool next = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
+            Assert.True(next);
             res.OnCompleted();
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNext_HasError()
         {
             var ex = new Exception();
             var e_ = default(Exception);
 
             bool next = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
+            Assert.True(next);
 
             try
             {
                 res.OnError(ex);
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
                 e_ = e;
             }
-            Assert.AreSame(ex, e_);
+            Assert.Same(ex, e_);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNextOnCompleted()
         {
             bool next = false;
             bool completed = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; }, () => { completed = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; }, () => { completed = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
-            Assert.IsFalse(completed);
+            Assert.True(next);
+            Assert.False(completed);
             res.OnCompleted();
-            Assert.IsTrue(completed);
+            Assert.True(completed);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNextOnCompleted_HasError()
         {
             var ex = new Exception();
@@ -154,115 +155,115 @@ namespace ReactiveTests.Tests
 
             bool next = false;
             bool completed = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; }, () => { completed = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; }, () => { completed = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
-            Assert.IsFalse(completed);
+            Assert.True(next);
+            Assert.False(completed);
             try
             {
                 res.OnError(ex);
-                Assert.Fail();
+                Assert.True(false);
             }
             catch (Exception e)
             {
                 e_ = e;
             }
-            Assert.AreSame(ex, e_);
-            Assert.IsFalse(completed);
+            Assert.Same(ex, e_);
+            Assert.False(completed);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNextOnError()
         {
             var ex = new Exception();
             bool next = true;
             bool error = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; }, e => { Assert.AreSame(ex, e); error = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; }, e => { Assert.Same(ex, e); error = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
-            Assert.IsFalse(error);
+            Assert.True(next);
+            Assert.False(error);
             res.OnError(ex);
-            Assert.IsTrue(error);
+            Assert.True(error);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNextOnError_HitCompleted()
         {
             var ex = new Exception();
             bool next = true;
             bool error = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; }, e => { Assert.AreSame(ex, e); error = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; }, e => { Assert.Same(ex, e); error = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
-            Assert.IsFalse(error);
+            Assert.True(next);
+            Assert.False(error);
             res.OnCompleted();
-            Assert.IsFalse(error);
+            Assert.False(error);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNextOnErrorOnCompleted1()
         {
             var ex = new Exception();
             bool next = true;
             bool error = false;
             bool completed = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; }, e => { Assert.AreSame(ex, e); error = true; }, () => { completed = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; }, e => { Assert.Same(ex, e); error = true; }, () => { completed = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
-            Assert.IsFalse(error);
-            Assert.IsFalse(completed);
+            Assert.True(next);
+            Assert.False(error);
+            Assert.False(completed);
             res.OnCompleted();
-            Assert.IsTrue(completed);
-            Assert.IsFalse(error);
+            Assert.True(completed);
+            Assert.False(error);
         }
 
-        [TestMethod]
+        [Fact]
         public void Create_OnNextOnErrorOnCompleted2()
         {
             var ex = new Exception();
             bool next = true;
             bool error = false;
             bool completed = false;
-            var res = Observer.Create<int>(x => { Assert.AreEqual(42, x); next = true; }, e => { Assert.AreSame(ex, e); error = true; }, () => { completed = true; });
+            var res = Observer.Create<int>(x => { Assert.Equal(42, x); next = true; }, e => { Assert.Same(ex, e); error = true; }, () => { completed = true; });
             res.OnNext(42);
-            Assert.IsTrue(next);
-            Assert.IsFalse(error);
-            Assert.IsFalse(completed);
+            Assert.True(next);
+            Assert.False(error);
+            Assert.False(completed);
             res.OnError(ex);
-            Assert.IsTrue(error);
-            Assert.IsFalse(completed);
+            Assert.True(error);
+            Assert.False(completed);
         }
 
-        [TestMethod]
+        [Fact]
         public void AsObserver_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.AsObserver<int>(default(IObserver<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void AsObserver_Hides()
         {
             var obs = new MyObserver();
             var res = obs.AsObserver();
 
-            Assert.IsFalse(object.ReferenceEquals(obs, res));
+            Assert.False(object.ReferenceEquals(obs, res));
         }
 
-        [TestMethod]
+        [Fact]
         public void AsObserver_Forwards()
         {
             var obsn = new MyObserver();
             obsn.AsObserver().OnNext(42);
-            Assert.AreEqual(obsn.HasOnNext, 42);
+            Assert.Equal(obsn.HasOnNext, 42);
 
             var ex = new Exception();
             var obse = new MyObserver();
             obse.AsObserver().OnError(ex);
-            Assert.AreSame(ex, obse.HasOnError);
+            Assert.Same(ex, obse.HasOnError);
 
             var obsc = new MyObserver();
             obsc.AsObserver().OnCompleted();
-            Assert.IsTrue(obsc.HasOnCompleted);
+            Assert.True(obsc.HasOnCompleted);
         }
 
         class MyObserver : IObserver<int>
@@ -287,19 +288,19 @@ namespace ReactiveTests.Tests
             public bool HasOnCompleted { get; set; }
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Checked_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.Checked(default(IObserver<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Checked_AlreadyTerminated_Completed()
         {
             var m = 0;
             var n = 0;
 
-            var o = Observer.Create<int>(_ => { m++; }, ex => { Assert.Fail(); }, () => { n++; }).Checked();
+            var o = Observer.Create<int>(_ => { m++; }, ex => { Assert.True(false); }, () => { n++; }).Checked();
 
             o.OnNext(1);
             o.OnNext(2);
@@ -308,17 +309,17 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => o.OnCompleted());
             ReactiveAssert.Throws<InvalidOperationException>(() => o.OnError(new Exception()));
 
-            Assert.AreEqual(2, m);
-            Assert.AreEqual(1, n);
+            Assert.Equal(2, m);
+            Assert.Equal(1, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Checked_AlreadyTerminated_Error()
         {
             var m = 0;
             var n = 0;
 
-            var o = Observer.Create<int>(_ => { m++; }, ex => { n++; }, () => { Assert.Fail(); }).Checked();
+            var o = Observer.Create<int>(_ => { m++; }, ex => { n++; }, () => { Assert.True(false); }).Checked();
 
             o.OnNext(1);
             o.OnNext(2);
@@ -327,11 +328,11 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => o.OnCompleted());
             ReactiveAssert.Throws<InvalidOperationException>(() => o.OnError(new Exception()));
 
-            Assert.AreEqual(2, m);
-            Assert.AreEqual(1, n);
+            Assert.Equal(2, m);
+            Assert.Equal(1, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Checked_Reentrant_Next()
         {
             var n = 0;
@@ -348,20 +349,20 @@ namespace ReactiveTests.Tests
                 },
                 ex =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 },
                 () =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 })
                 .Checked();
 
             o.OnNext(1);
 
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Checked_Reentrant_Error()
         {
             var n = 0;
@@ -370,7 +371,7 @@ namespace ReactiveTests.Tests
             o = Observer.Create<int>(
                 _ =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 },
                 ex =>
                 {
@@ -382,16 +383,16 @@ namespace ReactiveTests.Tests
                 },
                 () =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 })
                 .Checked();
 
             o.OnError(new Exception());
 
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Checked_Reentrant_Completed()
         {
             var n = 0;
@@ -400,11 +401,11 @@ namespace ReactiveTests.Tests
             o = Observer.Create<int>(
                 _ =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 },
                 ex =>
                 {
-                    Assert.Fail();
+                    Assert.True(false);
                 },
                 () =>
                 {
@@ -418,10 +419,10 @@ namespace ReactiveTests.Tests
 
             o.OnCompleted();
 
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.Synchronize(default(IObserver<int>)));
@@ -435,7 +436,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.Synchronize(new MyObserver(), default(AsyncLock)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_Monitor_Reentrant1()
         {
             var res = false;
@@ -461,10 +462,10 @@ namespace ReactiveTests.Tests
 
             s.OnNext(1);
 
-            Assert.IsTrue(res);
+            Assert.True(res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_Monitor_Reentrant2()
         {
             var res = false;
@@ -490,10 +491,10 @@ namespace ReactiveTests.Tests
 
             s.OnNext(1);
 
-            Assert.IsTrue(res);
+            Assert.True(res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_Monitor_Reentrant3()
         {
             var res = false;
@@ -519,10 +520,10 @@ namespace ReactiveTests.Tests
 
             s.OnNext(1);
 
-            Assert.IsTrue(res);
+            Assert.True(res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_AsyncLock_NonReentrant1()
         {
             var res = false;
@@ -548,10 +549,10 @@ namespace ReactiveTests.Tests
 
             s.OnNext(1);
 
-            Assert.IsTrue(res);
+            Assert.True(res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_AsyncLock_NonReentrant2()
         {
             var res = false;
@@ -577,10 +578,10 @@ namespace ReactiveTests.Tests
 
             s.OnNext(1);
 
-            Assert.IsTrue(res);
+            Assert.True(res);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_AsyncLock()
         {
             {
@@ -590,15 +591,15 @@ namespace ReactiveTests.Tests
 
                 var o = Observer.Create<int>(
                     x => { res = x == 1; },
-                    ex => { Assert.Fail(); },
-                    () => { Assert.Fail(); }
+                    ex => { Assert.True(false); },
+                    () => { Assert.True(false); }
                 );
 
                 s = Observer.Synchronize(o, true);
 
                 s.OnNext(1);
 
-                Assert.IsTrue(res);
+                Assert.True(res);
             }
 
             {
@@ -609,16 +610,16 @@ namespace ReactiveTests.Tests
                 var s = default(IObserver<int>);
 
                 var o = Observer.Create<int>(
-                    x => { Assert.Fail(); },
+                    x => { Assert.True(false); },
                     ex => { res = ex; },
-                    () => { Assert.Fail(); }
+                    () => { Assert.True(false); }
                 );
 
                 s = Observer.Synchronize(o, true);
 
                 s.OnError(err);
 
-                Assert.AreSame(err, res);
+                Assert.Same(err, res);
             }
 
             {
@@ -627,8 +628,8 @@ namespace ReactiveTests.Tests
                 var s = default(IObserver<int>);
 
                 var o = Observer.Create<int>(
-                    x => { Assert.Fail(); },
-                    ex => { Assert.Fail(); },
+                    x => { Assert.True(false); },
+                    ex => { Assert.True(false); },
                     () => { res = true; }
                 );
 
@@ -636,18 +637,18 @@ namespace ReactiveTests.Tests
 
                 s.OnCompleted();
 
-                Assert.IsTrue(res);
+                Assert.True(res);
             }
         }
 
 #if !NO_CDS
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_OnCompleted()
         {
             Observer_Synchronize(true);
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_Synchronize_OnError()
         {
             Observer_Synchronize(false);
@@ -664,21 +665,21 @@ namespace ReactiveTests.Tests
             var o = Observer.Create<int>(
                 _ =>
                 {
-                    Assert.IsFalse(busy);
+                    Assert.False(busy);
                     busy = true;
                     n++;
                     busy = false;
                 },
                 _ =>
                 {
-                    Assert.IsFalse(busy);
+                    Assert.False(busy);
                     busy = true;
                     ex = _;
                     busy = false;
                 },
                 () =>
                 {
-                    Assert.IsFalse(busy);
+                    Assert.False(busy);
                     busy = true;
                     done = true;
                     busy = false;
@@ -706,20 +707,20 @@ namespace ReactiveTests.Tests
             if (success)
             {
                 s.OnCompleted();
-                Assert.IsTrue(done);
+                Assert.True(done);
             }
             else
             {
                 var err = new Exception();
                 s.OnError(err);
-                Assert.AreSame(err, ex);
+                Assert.Same(err, ex);
             }
 
-            Assert.AreEqual(n, N * M);
+            Assert.Equal(n, N * M);
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void NotifyOn_Null()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.NotifyOn(default(IObserver<int>), Scheduler.Immediate));
@@ -731,13 +732,14 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void NotifyOn_Scheduler_OnCompleted()
         {
             NotifyOn_Scheduler(true);
         }
 
-        [TestMethod]
+        [Fact]
         public void NotifyOn_Scheduler_OnError()
         {
             NotifyOn_Scheduler(false);
@@ -755,18 +757,18 @@ namespace ReactiveTests.Tests
                 {
                     c++;
 #if DESKTOPCLR
-                    Assert.IsTrue(Thread.CurrentThread.IsThreadPoolThread);
+                    Assert.True(Thread.CurrentThread.IsThreadPoolThread);
 #endif
                 },
                 ex =>
                 {
-                    Assert.AreSame(err, ex);
+                    Assert.Same(err, ex);
                     e.Set();
                 },
                 () =>
                 {
 #if DESKTOPCLR
-                    Assert.IsTrue(Thread.CurrentThread.IsThreadPoolThread);
+                    Assert.True(Thread.CurrentThread.IsThreadPoolThread);
 #endif
                     e.Set();
                 }
@@ -787,15 +789,16 @@ namespace ReactiveTests.Tests
             }).Start();
 
             e.WaitOne();
-            Assert.AreEqual(N, c);
+            Assert.Equal(N, c);
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void NotifyOn_SyncCtx()
         {
             var lst = new List<int>();
             var don = new ManualResetEvent(false);
-            var obs = Observer.Create<int>(x => { lst.Add(x); }, ex => { Assert.Fail(); }, () => { don.Set(); });
+            var obs = Observer.Create<int>(x => { lst.Add(x); }, ex => { Assert.True(false); }, () => { don.Set(); });
             var ctx = new MySyncCtx();
             var res = obs.NotifyOn(ctx);
 
@@ -804,20 +807,20 @@ namespace ReactiveTests.Tests
             obs.OnCompleted();
 
             don.WaitOne();
-            Assert.IsTrue(lst.SequenceEqual(Enumerable.Range(0, 100)));
+            Assert.True(lst.SequenceEqual(Enumerable.Range(0, 100)));
         }
 
         class MySyncCtx : SynchronizationContext
         {
             public override void Post(SendOrPostCallback d, object state)
             {
-                ThreadPool.QueueUserWorkItem(_ => d(state), state);
+                Task.Run(() => d(state));
             }
         }
 
 #if HAS_PROGRESS
 
-        [TestMethod]
+        [Fact]
         public void Observer_ToProgress_ArgumentChecking()
         {
             var s = Scheduler.Immediate;
@@ -829,7 +832,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.ToProgress<int>(o, default(IScheduler)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_ToProgress()
         {
             var xs = new List<int>();
@@ -839,10 +842,10 @@ namespace ReactiveTests.Tests
             p.Report(42);
             p.Report(43);
 
-            Assert.IsTrue(xs.SequenceEqual(new[] { 42, 43 }));
+            Assert.True(xs.SequenceEqual(new[] { 42, 43 }));
         }
 
-        [TestMethod]
+        [Fact]
         public void Observer_ToProgress_Scheduler()
         {
             var s = new TestScheduler();
@@ -864,13 +867,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Progress_ToObserver_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observer.ToObserver(default(IProgress<int>)));
         }
 
-        [TestMethod]
+        [Fact]
         public void Progress_ToObserver()
         {
             var xs = new List<int>();
@@ -882,7 +885,7 @@ namespace ReactiveTests.Tests
             o.OnNext(42);
             o.OnNext(43);
 
-            Assert.IsTrue(xs.SequenceEqual(new[] { 42, 43 }));
+            Assert.True(xs.SequenceEqual(new[] { 42, 43 }));
         }
 
         class MyProgress<T> : IProgress<T>

Rx.NET/Source/Tests.System.Reactive/Tests/PrivateTypesTest.cs

@@ -3,124 +3,125 @@
 #if !SILVERLIGHT // Reflection security restrictions
 using System;
 using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 using Microsoft.Reactive.Testing;
 using System.Reactive.Linq;
+using System.Reflection;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public partial class PrivateTypesTest : ReactiveTest
     {
-        [TestMethod]
+        [Fact]
         public void EitherValueRoundtrip()
         {
             {
                 var value = 42;
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(value);
-                Assert.AreEqual(value, left.Value);
+                Assert.Equal(value, left.Value);
             }
             {
                 var value = "42";
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight(value);
-                Assert.AreEqual(value, right.Value);
+                Assert.Equal(value, right.Value);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EitherEqualsEquatable()
         {
             {
                 var value = 42;
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(value);
 
-                Assert.IsTrue(left.Equals(left));
-                Assert.IsFalse(left.Equals((Either<int, string>.Left)null));
+                Assert.True(left.Equals(left));
+                Assert.False(left.Equals((Either<int, string>.Left)null));
 
                 var other = (Either<int, string>.Left)Either<int, string>.CreateLeft(value + 1);
-                Assert.IsFalse(left.Equals(other));
+                Assert.False(left.Equals(other));
             }
             {
                 var value = "42";
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight(value);
 
-                Assert.IsTrue(right.Equals(right));
-                Assert.IsFalse(right.Equals((Either<int, string>.Right)null));
+                Assert.True(right.Equals(right));
+                Assert.False(right.Equals((Either<int, string>.Right)null));
 
                 var other = (Either<int, string>.Right)Either<int, string>.CreateRight(value + "1");
-                Assert.IsFalse(right.Equals(other));
+                Assert.False(right.Equals(other));
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EitherEqualsObject()
         {
             {
                 var value = 42;
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(value);
 
-                Assert.IsTrue(left.Equals((object)left));
-                Assert.IsFalse(left.Equals((object)null));
+                Assert.True(left.Equals((object)left));
+                Assert.False(left.Equals((object)null));
 
                 var other = (Either<int, string>.Left)Either<int, string>.CreateLeft(value + 1);
-                Assert.IsFalse(left.Equals((object)other));
+                Assert.False(left.Equals((object)other));
             }
             {
                 var value = "42";
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight(value);
 
-                Assert.IsTrue(right.Equals((object)right));
-                Assert.IsFalse(right.Equals((object)null));
+                Assert.True(right.Equals((object)right));
+                Assert.False(right.Equals((object)null));
 
                 var other = (Either<int, string>.Right)Either<int, string>.CreateRight(value + "1");
-                Assert.IsFalse(right.Equals((object)other));
+                Assert.False(right.Equals((object)other));
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EitherGetHashCode()
         {
             {
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(42);
                 var other = (Either<int, string>.Left)Either<int, string>.CreateLeft(43);
-                Assert.AreNotEqual(left.GetHashCode(), other.GetHashCode());
+                Assert.NotEqual(left.GetHashCode(), other.GetHashCode());
             }
             {
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight("42");
                 var other = (Either<int, string>.Right)Either<int, string>.CreateRight("43");
-                Assert.AreNotEqual(right.GetHashCode(), other.GetHashCode());
+                Assert.NotEqual(right.GetHashCode(), other.GetHashCode());
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EitherToString()
         {
             {
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(42);
-                Assert.IsTrue(left.ToString() == "Left(42)");
+                Assert.True(left.ToString() == "Left(42)");
             }
             {
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight("42");
-                Assert.IsTrue(right.ToString() == "Right(42)");
+                Assert.True(right.ToString() == "Right(42)");
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EitherSwitchFunc()
         {
             {
                 var value = 42;
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(value);
-                Assert.AreEqual(left.Switch<int>(l => l, r => r.Length), value);
+                Assert.Equal(left.Switch<int>(l => l, r => r.Length), value);
             }
             {
                 var value = "42";
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight(value);
-                Assert.AreEqual(right.Switch<int>(l => l, r => r.Length), value.Length);
+                Assert.Equal(right.Switch<int>(l => l, r => r.Length), value.Length);
             }
         }
 
-        [TestMethod]
+        [Fact]
         public void EitherSwitchAction()
         {
             {
@@ -128,14 +129,14 @@ namespace ReactiveTests.Tests
                 var left = (Either<int, string>.Left)Either<int, string>.CreateLeft(value);
                 int res = 0;
                 left.Switch(l => { res = 1; }, r => { res = 2;});
-                Assert.AreEqual(1, res);
+                Assert.Equal(1, res);
             }
             {
                 var value = "42";
                 var right = (Either<int, string>.Right)Either<int, string>.CreateRight(value);
                 int res = 0;
                 right.Switch(l => { res = 1; }, r => { res = 2; });
-                Assert.AreEqual(2, res);
+                Assert.Equal(2, res);
             }
         }
     }
@@ -165,7 +166,7 @@ namespace ReactiveTests.Tests
     {
         public static Either<TLeft, TRight> CreateLeft(TLeft value)
         {
-            var tpe = typeof(Observable).Assembly.GetTypes().Single(t => t.Name == "Either`2").MakeGenericType(typeof(TLeft), typeof(TRight));
+            var tpe = typeof(Observable).GetTypeInfo().Assembly.GetTypes().Single(t => t.Name == "Either`2").MakeGenericType(typeof(TLeft), typeof(TRight));
             var mth = tpe.GetMethod("CreateLeft");
             var res = mth.Invoke(null, new object[] { value });
             return new Either<TLeft, TRight>.Left(res);
@@ -173,7 +174,7 @@ namespace ReactiveTests.Tests
 
         public static Either<TLeft, TRight> CreateRight(TRight value)
         {
-            var tpe = typeof(Observable).Assembly.GetTypes().Single(t => t.Name == "Either`2").MakeGenericType(typeof(TLeft), typeof(TRight));
+            var tpe = typeof(Observable).GetTypeInfo().Assembly.GetTypes().Single(t => t.Name == "Either`2").MakeGenericType(typeof(TLeft), typeof(TRight));
             var mth = tpe.GetMethod("CreateRight");
             var res = mth.Invoke(null, new object[] { value });
             return new Either<TLeft, TRight>.Right(res);

Rx.NET/Source/Tests.System.Reactive/Tests/RegressionTest.cs

@@ -9,15 +9,15 @@ using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class RegressionTest : ReactiveTest
     {
 #if DESKTOPCLR40 || DESKTOPCLR45 || DESKTOPCLR46
-        [TestMethod]
+        [Fact]
         public void Bug_ConcurrentMerge()
         {
             const int reps = 1000;
@@ -38,11 +38,11 @@ namespace ReactiveTests.Tests
                 return () => { };
             })).Merge(3).ForEach(_ => { });
 
-            Assert.IsTrue(Enumerable.Range(0, reps).ToList().SequenceEqual(resultQueue.ToList()));
+            Assert.True(Enumerable.Range(0, reps).ToList().SequenceEqual(resultQueue.ToList()));
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void Bug_1283()
         {
             var scheduler = new TestScheduler();
@@ -71,7 +71,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1261()
         {
             var scheduler = new TestScheduler();
@@ -103,14 +103,15 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1130()
         {
             var xs = Observable.Start(() => 5);
-            Assert.IsNull(xs as ISubject<int, int>);
+            Assert.Null(xs as ISubject<int, int>);
         }
 
-        [TestMethod]
+#if !NO_THREAD
+        [Fact]
         public void Bug_1286()
         {
             var infinite = Observable.Return(new { Name = "test", Value = 0d }, DefaultScheduler.Instance).Repeat();
@@ -124,17 +125,19 @@ namespace ReactiveTests.Tests
             //if the first doesn't this one always
             disp.Dispose();
         }
+#endif
 
-        [TestMethod]
+        [Fact]
         public void Bug_1287()
         {
             var flag = false;
             var x = Observable.Return(1, Scheduler.CurrentThread).Concat(Observable.Never<int>()).Finally(() => flag = true).First();
-            Assert.AreEqual(1, x);
-            Assert.IsTrue(flag);
+            Assert.Equal(1, x);
+            Assert.True(flag);
         }
 
 #if !SILVERLIGHTM7
+#if !NO_THREAD
         static IEnumerable<int> Bug_1333_Enumerable(AsyncSubject<IDisposable> s, Semaphore sema)
         {
             var d = s.First();
@@ -143,9 +146,10 @@ namespace ReactiveTests.Tests
             t.Join();
             yield return 1;
         }
-
-        [TestMethod]
-        [Timeout(1000)]
+#endif
+#if !NO_THREAD
+        [Fact]
+        //[Timeout(1000)]
         public void Bug_1333()
         {
             var sema = new Semaphore(0, 1);
@@ -155,9 +159,10 @@ namespace ReactiveTests.Tests
             d.OnCompleted();
             sema.WaitOne();
         }
+#endif
 #endif
 
-        [TestMethod]
+        [Fact]
         public void Bug_1295_Completed()
         {
             var scheduler = new TestScheduler();
@@ -184,7 +189,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1295_Error()
         {
             var scheduler = new TestScheduler();
@@ -212,7 +217,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1297_Catch_None()
         {
             var scheduler = new TestScheduler();
@@ -226,7 +231,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1297_OnErrorResumeNext_None()
         {
             var scheduler = new TestScheduler();
@@ -240,7 +245,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1297_Catch_Single()
         {
             var scheduler = new TestScheduler();
@@ -258,7 +263,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1297_OnErrorResumeNext_Single()
         {
             var scheduler = new TestScheduler();
@@ -274,7 +279,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1297_Catch_Multi()
         {
             var scheduler = new TestScheduler();
@@ -296,7 +301,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1297_OnErrorResumeNext_Multi()
         {
             var scheduler = new TestScheduler();
@@ -318,7 +323,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1380()
         {
             var scheduler = new TestScheduler();
@@ -353,15 +358,15 @@ namespace ReactiveTests.Tests
         }
 
 
-        [TestMethod]
+        [Fact]
         public void Bug_1356()
         {
             var run = false;
             Observable.Range(0, 10).Finally(() => run = true).Take(5).ForEach(_ => { });
-            Assert.IsTrue(run);
+            Assert.True(run);
         }
 
-        [TestMethod]
+        [Fact]
         public void Bug_1381()
         {
             var scheduler = new TestScheduler();
@@ -407,7 +412,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void Reentrant_Subject1()
         {
             var s = Subject.Synchronize((ISubject<int, int>)new Subject<int>(), Scheduler.Immediate);
@@ -427,7 +432,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(1, -1, 2, -2, 3, -3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Reentrant_Subject2()
         {
             var s = Subject.Synchronize(new Subject<int>(), Scheduler.Immediate);
@@ -447,7 +452,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(1, -1, 2, -2, 3, -3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Merge_Trampoline1()
         {
             var ys = new[] { 1, 2, 3 }.ToObservable().Publish(xs => xs.Merge(xs));
@@ -458,7 +463,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(1, 1, 2, 2, 3, 3);
         }
 
-        [TestMethod]
+        [Fact]
         public void Merge_Trampoline2()
         {
             var ys = new[] { 1, 2, 3 }.ToObservable().Publish(xs => Observable.Merge(xs, xs, xs, xs));

Rx.NET/Source/Tests.System.Reactive/Tests/SystemClockTest.cs

@@ -7,7 +7,7 @@ using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.PlatformServices;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
@@ -21,7 +21,7 @@ namespace ReactiveTests.Tests
         }
     }
 
-    [TestClass]
+    
     public class SystemClockTest
     {
         private void Run(CrossAppDomainDelegate a)
@@ -31,7 +31,7 @@ namespace ReactiveTests.Tests
             AppDomain.Unload(domain);
         }
 
-        [TestMethod]
+        [Fact]
         public void PastWork()
         {
             Run(PastWork_Callback);
@@ -52,18 +52,18 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == now);
+            Assert.True(s.Now + next.DueTime == now);
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void ImmediateWork()
         {
             Run(ImmediateWork_Callback);
@@ -84,18 +84,18 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.True(s.Now + next.DueTime == due);
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void ShortTermWork()
         {
             Run(ShortTermWork_Callback);
@@ -117,18 +117,18 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.True(s.Now + next.DueTime == due);
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void ShortTermWork_Dispose()
         {
             Run(ShortTermWork_Dispose_Callback);
@@ -150,20 +150,20 @@ namespace ReactiveTests.Tests
             var done = false;
             var d = s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.True(s.Now + next.DueTime == due);
 
             d.Dispose();
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsFalse(done);
+            Assert.False(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void ShortTermWork_InaccurateClock()
         {
             Run(ShortTermWork_InaccurateClock_Callback);
@@ -185,26 +185,26 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var nxt1 = s._queue.Deq();
-            Assert.IsTrue(s.Now + nxt1.DueTime == due);
+            Assert.True(s.Now + nxt1.DueTime == due);
 
             s.SetTime(due - TimeSpan.FromMilliseconds(500) /* > RETRYSHORT */);
             nxt1.Invoke();
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var nxt2 = s._queue.Deq();
-            Assert.IsTrue(s.Now + nxt2.DueTime == due);
+            Assert.True(s.Now + nxt2.DueTime == due);
 
             s.SetTime(due);
             nxt2.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void LongTermWork1()
         {
             Run(LongTermWork1_Callback);
@@ -226,26 +226,26 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
 
             var work = cal._queue.Deq();
-            Assert.IsTrue(work.Interval < rel);
+            Assert.True(work.Interval < rel);
 
             s.SetTime(s.Now + work.Interval);
             work.Value._action(work.Value._state);
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.True(s.Now + next.DueTime == due);
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void LongTermWork2()
         {
             Run(LongTermWork2_Callback);
@@ -267,36 +267,36 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
 
             var wrk1 = cal._queue.Deq();
-            Assert.IsTrue(wrk1.Interval < rel);
+            Assert.True(wrk1.Interval < rel);
 
             s.SetTime(s.Now + wrk1.Interval);
             wrk1.Value._action(wrk1.Value._state);
 
             // Begin of second long term scheduling
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
 
             var wrk2 = cal._queue.Deq();
-            Assert.IsTrue(wrk2.Interval < rel);
+            Assert.True(wrk2.Interval < rel);
 
             s.SetTime(s.Now + wrk2.Interval);
             wrk2.Value._action(wrk2.Value._state);
             // End of second long term scheduling
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.True(s.Now + next.DueTime == due);
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void LongTerm_Multiple()
         {
             Run(LongTerm_Multiple_Callback);
@@ -326,64 +326,64 @@ namespace ReactiveTests.Tests
             s.Schedule(due3, () => { done3 = true; });
 
             // First CHK
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
             var wrk1 = cal._queue.Deq();
             var fst = s.Now + wrk1.Interval;
-            Assert.IsTrue(fst < due1);
+            Assert.True(fst < due1);
 
             // First TRN
             s.SetTime(fst);
             wrk1.Value._action(wrk1.Value._state);
 
             // First SHT
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var sh1 = s._queue.Deq();
 
             // Second CHK
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
             var wrk2 = cal._queue.Deq();
             var snd = s.Now + wrk2.Interval;
-            Assert.IsTrue(snd < due2);
+            Assert.True(snd < due2);
 
             // First RUN
             s.SetTime(due1);
             sh1.Invoke();
-            Assert.IsTrue(done1);
+            Assert.True(done1);
 
             // Second TRN
             s.SetTime(snd);
             wrk2.Value._action(wrk2.Value._state);
 
             // Second SHT
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var sh2 = s._queue.Deq();
 
             // Third CHK
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
             var wrk3 = cal._queue.Deq();
             var trd = s.Now + wrk3.Interval;
-            Assert.IsTrue(trd < due3);
+            Assert.True(trd < due3);
 
             // Second RUN
             s.SetTime(due2);
             sh2.Invoke();
-            Assert.IsTrue(done2);
+            Assert.True(done2);
 
             // Third TRN
             s.SetTime(trd);
             wrk3.Value._action(wrk3.Value._state);
 
             // Third SHT
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var sh3 = s._queue.Deq();
 
             // Third RUN
             s.SetTime(due3);
             sh3.Invoke();
-            Assert.IsTrue(done3);
+            Assert.True(done3);
         }
 
-        [TestMethod]
+        [Fact]
         public void LongTerm_Multiple_Dispose()
         {
             Run(LongTerm_Multiple_Dispose_Callback);
@@ -413,10 +413,10 @@ namespace ReactiveTests.Tests
             var d3 = s.Schedule(due3, () => { done3 = true; });
 
             // First CHK
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
             var wrk1 = cal._queue.Deq();
             var fst = s.Now + wrk1.Interval;
-            Assert.IsTrue(fst < due1);
+            Assert.True(fst < due1);
 
             // First TRN
             s.SetTime(fst);
@@ -426,19 +426,19 @@ namespace ReactiveTests.Tests
             d1.Dispose();
 
             // First SHT
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var sh1 = s._queue.Deq();
 
             // Second CHK
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
             var wrk2 = cal._queue.Deq();
             var snd = s.Now + wrk2.Interval;
-            Assert.IsTrue(snd < due2);
+            Assert.True(snd < due2);
 
             // First RUN
             s.SetTime(due1);
             sh1.Invoke();
-            Assert.IsFalse(done1);
+            Assert.False(done1);
 
             // Second DIS
             // Third DIS
@@ -450,35 +450,35 @@ namespace ReactiveTests.Tests
             wrk2.Value._action(wrk2.Value._state);
 
             // Second SHT
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var sh2 = s._queue.Deq();
 
             // Third CHK
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
             var wrk3 = cal._queue.Deq();
             var trd = s.Now + wrk3.Interval;
-            Assert.IsTrue(trd < due3);
+            Assert.True(trd < due3);
 
             // Second RUN
             s.SetTime(due2);
             sh2.Invoke();
-            Assert.IsFalse(done2);
+            Assert.False(done2);
 
             // Third TRN
             s.SetTime(trd);
             wrk3.Value._action(wrk3.Value._state);
 
             // Third SHT
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var sh3 = s._queue.Deq();
 
             // Third RUN
             s.SetTime(due3);
             sh3.Invoke();
-            Assert.IsFalse(done3);
+            Assert.False(done3);
         }
 
-        [TestMethod]
+        [Fact]
         public void ClockChanged_FalsePositive()
         {
             Run(ClockChanged_FalsePositive_Callback);
@@ -502,29 +502,29 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
 
             s.SetTime(now);
             scm.OnSystemClockChanged();
 
             var work = cal._queue.Deq();
-            Assert.IsTrue(work.Interval < rel);
+            Assert.True(work.Interval < rel);
 
             s.SetTime(s.Now + work.Interval);
             work.Value._action(work.Value._state);
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.True(s.Now + next.DueTime == due);
 
             s.SetTime(due);
             next.Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void ClockChanged_Forward1()
         {
             Run(ClockChanged_Forward1_Callback);
@@ -549,27 +549,27 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, cal._queue.Count);
-            Assert.AreEqual(0, s._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
+            Assert.Equal(0, s._queue.Count);
 
             s.SetTime(due + err);
             scm.OnSystemClockChanged();
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(next.DueTime == TimeSpan.Zero);
+            Assert.True(next.DueTime == TimeSpan.Zero);
             next.Invoke();
-            Assert.IsTrue(done);
+            Assert.True(done);
 
             var tmr = cal._queue.Deq();
             tmr.Value._action(tmr.Value._state);
 
-            Assert.AreEqual(0, cal._queue.Count);
-            Assert.AreEqual(0, s._queue.Count);
+            Assert.Equal(0, cal._queue.Count);
+            Assert.Equal(0, s._queue.Count);
         }
 
-        [TestMethod]
+        [Fact]
         public void ClockChanged_Forward2()
         {
             Run(ClockChanged_Forward2_Callback);
@@ -594,26 +594,26 @@ namespace ReactiveTests.Tests
             var n = 0;
             s.Schedule(due, () => { n++; });
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var wrk = s._queue.Deq();
-            Assert.IsTrue(wrk.DueTime == rel);
+            Assert.True(wrk.DueTime == rel);
 
             s.SetTime(due + err);
             scm.OnSystemClockChanged();
 
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             var next = s._queue.Deq();
-            Assert.IsTrue(next.DueTime == TimeSpan.Zero);
+            Assert.True(next.DueTime == TimeSpan.Zero);
             next.Invoke();
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
 
             wrk.Invoke(); // Bad schedulers may not grant cancellation immediately.
-            Assert.AreEqual(1, n); // Invoke shouldn't cause double execution of the work.
+            Assert.Equal(1, n); // Invoke shouldn't cause double execution of the work.
         }
 
-        [TestMethod]
+        [Fact]
         public void ClockChanged_Backward1()
         {
             Run(ClockChanged_Backward1_Callback);
@@ -638,35 +638,35 @@ namespace ReactiveTests.Tests
             var done = false;
             s.Schedule(due, () => { done = true; });
 
-            Assert.AreEqual(1, cal._queue.Count);
-            Assert.IsTrue(cal._queue[0].Interval < rel);
+            Assert.Equal(1, cal._queue.Count);
+            Assert.True(cal._queue[0].Interval < rel);
 
-            Assert.AreEqual(0, s._queue.Count);
+            Assert.Equal(0, s._queue.Count);
 
             s.SetTime(due + err);
             scm.OnSystemClockChanged();
 
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
 
             var tmr = cal._queue.Deq();
-            Assert.IsTrue(tmr.Interval > rel);
-            Assert.IsTrue(tmr.Interval < -err);
+            Assert.True(tmr.Interval > rel);
+            Assert.True(tmr.Interval < -err);
 
             s.SetTime(s.Now + tmr.Interval);
             tmr.Value._action(tmr.Value._state);
 
-            Assert.IsFalse(done);
+            Assert.False(done);
 
-            Assert.AreEqual(0, cal._queue.Count);
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(0, cal._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             s.SetTime(due);
             s._queue.Deq().Invoke();
 
-            Assert.IsTrue(done);
+            Assert.True(done);
         }
 
-        [TestMethod]
+        [Fact]
         public void ClockChanged_Backward2()
         {
             Run(ClockChanged_Backward2_Callback);
@@ -691,38 +691,38 @@ namespace ReactiveTests.Tests
             var n = 0;
             s.Schedule(due, () => { n++; });
 
-            Assert.AreEqual(0, cal._queue.Count);
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(0, cal._queue.Count);
+            Assert.Equal(1, s._queue.Count);
             var wrk = s._queue[0];
-            Assert.IsTrue(wrk.DueTime == rel);
+            Assert.True(wrk.DueTime == rel);
 
             s.SetTime(due + err);
             scm.OnSystemClockChanged();
 
-            Assert.AreEqual(1, cal._queue.Count);
+            Assert.Equal(1, cal._queue.Count);
 
             var tmr = cal._queue.Deq();
-            Assert.IsTrue(tmr.Interval > rel);
-            Assert.IsTrue(tmr.Interval < -err);
+            Assert.True(tmr.Interval > rel);
+            Assert.True(tmr.Interval < -err);
 
             s.SetTime(s.Now + tmr.Interval);
             tmr.Value._action(tmr.Value._state);
 
-            Assert.AreEqual(0, n);
+            Assert.Equal(0, n);
 
-            Assert.AreEqual(0, cal._queue.Count);
-            Assert.AreEqual(1, s._queue.Count);
+            Assert.Equal(0, cal._queue.Count);
+            Assert.Equal(1, s._queue.Count);
 
             s.SetTime(due);
             s._queue.Deq().Invoke();
 
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
 
             wrk.Invoke(); // Bad schedulers may not grant cancellation immediately.
-            Assert.AreEqual(1, n); // Invoke shouldn't cause double execution of the work.
+            Assert.Equal(1, n); // Invoke shouldn't cause double execution of the work.
         }
 
-        [TestMethod]
+        [Fact]
         public void PeriodicSystemClockChangeMonitor()
         {
             Run(PeriodicSystemClockChangeMonitor_Callback);
@@ -751,48 +751,48 @@ namespace ReactiveTests.Tests
 
             ptscm.SystemClockChanged += h;
 
-            Assert.IsNotNull(cal._action);
-            Assert.IsTrue(cal._period == period);
-            Assert.AreEqual(0, n);
+            Assert.NotNull(cal._action);
+            Assert.True(cal._period == period);
+            Assert.Equal(0, n);
 
             clock._now += period;
             cal._action();
-            Assert.AreEqual(0, n);
+            Assert.Equal(0, n);
 
             clock._now += period;
             cal._action();
-            Assert.AreEqual(0, n);
+            Assert.Equal(0, n);
 
             var diff1 = TimeSpan.FromSeconds(3);
             clock._now += period + diff1;
             cal._action();
-            Assert.AreEqual(1, n);
-            Assert.IsTrue(delta == diff1);
+            Assert.Equal(1, n);
+            Assert.True(delta == diff1);
 
             clock._now += period;
             cal._action();
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
 
             clock._now += period;
             cal._action();
-            Assert.AreEqual(1, n);
+            Assert.Equal(1, n);
 
             var diff2 = TimeSpan.FromSeconds(-5);
             clock._now += period + diff2;
             cal._action();
-            Assert.AreEqual(2, n);
-            Assert.IsTrue(delta == diff2);
+            Assert.Equal(2, n);
+            Assert.True(delta == diff2);
 
             clock._now += period;
             cal._action();
-            Assert.AreEqual(2, n);
+            Assert.Equal(2, n);
 
             ptscm.SystemClockChanged -= h;
 
-            Assert.IsNull(cal._action);
+            Assert.Null(cal._action);
         }
 
-        [TestMethod]
+        [Fact]
         public void ClockChanged_RefCounting()
         {
             Run(ClockChanged_RefCounting_Callback);
@@ -834,21 +834,21 @@ namespace ReactiveTests.Tests
             d2.Dispose();
             d4.Dispose();
 
-            Assert.AreEqual(1, scm.n);
+            Assert.Equal(1, scm.n);
 
             s.SetTime(due1);
             var i1 = s._queue.Deq();
             i1.Invoke();
-            Assert.IsTrue(done1);
+            Assert.True(done1);
 
-            Assert.AreEqual(1, scm.n);
+            Assert.Equal(1, scm.n);
 
             s.SetTime(due2);
             var i2 = s._queue.Deq();
             i2.Invoke();
-            Assert.IsFalse(done2);
+            Assert.False(done2);
 
-            Assert.AreEqual(1, scm.n);
+            Assert.Equal(1, scm.n);
 
             var l1 = cal._queue.Deq();
             var l1d = now + l1.Interval;
@@ -860,12 +860,12 @@ namespace ReactiveTests.Tests
             try
             {
                 i3.Invoke();
-                Assert.Fail();
+                Assert.True(false);
             }
             catch { }
-            Assert.IsTrue(done3);
+            Assert.True(done3);
 
-            Assert.AreEqual(1, scm.n);
+            Assert.Equal(1, scm.n);
 
             var l2 = cal._queue.Deq();
             var l2d = l1d + l2.Interval;
@@ -875,9 +875,9 @@ namespace ReactiveTests.Tests
             s.SetTime(due4);
             var i4 = s._queue.Deq();
             i4.Invoke();
-            Assert.IsFalse(done4);
+            Assert.False(done4);
 
-            Assert.AreEqual(1, scm.n);
+            Assert.Equal(1, scm.n);
 
             var l3 = cal._queue.Deq();
             var l3d = l2d + l3.Interval;
@@ -887,20 +887,20 @@ namespace ReactiveTests.Tests
             s.SetTime(due5);
             var i5 = s._queue.Deq();
             i5.Invoke();
-            Assert.IsTrue(done5);
+            Assert.True(done5);
 
-            Assert.AreEqual(0, scm.n);
+            Assert.Equal(0, scm.n);
 
             var d6 = s.Schedule(due6, () => { done6 = true; });
 
-            Assert.AreEqual(1, scm.n);
+            Assert.Equal(1, scm.n);
 
             s.SetTime(due6);
             var i6 = s._queue.Deq();
             i6.Invoke();
-            Assert.IsTrue(done6);
+            Assert.True(done6);
 
-            Assert.AreEqual(0, scm.n);
+            Assert.Equal(0, scm.n);
         }
 
         class MyScheduler : LocalScheduler

Rx.NET/Source/Tests.System.Reactive/Tests/TaskObservableExtensionsTest.cs

@@ -10,11 +10,11 @@ using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class TaskObservableExtensionsTest : ReactiveTest
     {
         private Task<int> doneTask;
@@ -28,7 +28,7 @@ namespace ReactiveTests.Tests
 
         #region ToObservable
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_ArgumentChecking()
         {
             var s = Scheduler.Immediate;
@@ -43,7 +43,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => task.ToObservable().Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Complete_BeforeCreate()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -70,7 +70,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Complete_BeforeSubscribe()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -97,7 +97,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Complete_BeforeDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -124,7 +124,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Complete_AfterDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -149,7 +149,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Exception_BeforeCreate()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -177,7 +177,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Exception_BeforeSubscribe()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -205,7 +205,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Exception_BeforeDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -233,7 +233,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Exception_AfterDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -258,7 +258,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Canceled_BeforeCreate()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -284,7 +284,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Canceled_BeforeSubscribe()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -310,7 +310,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Canceled_BeforeDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -336,7 +336,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Canceled_AfterDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -362,7 +362,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_NonVoid_Scheduler()
         {
             var e = new ManualResetEvent(false);
@@ -383,12 +383,12 @@ namespace ReactiveTests.Tests
 
             e.WaitOne();
 
-            Assert.AreEqual(42, x);
-            Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, t);
+            Assert.Equal(42, x);
+            Assert.Equal(Thread.CurrentThread.ManagedThreadId, t);
         }
 #endif
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_ArgumentChecking()
         {
             var s = Scheduler.Immediate;
@@ -403,7 +403,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => task.ToObservable().Subscribe(null));
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Complete_BeforeCreate()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -430,7 +430,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Complete_BeforeSubscribe()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -457,7 +457,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Complete_BeforeDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -484,7 +484,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Complete_AfterDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -509,7 +509,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Exception_BeforeCreate()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -537,7 +537,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Exception_BeforeSubscribe()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -565,7 +565,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Exception_BeforeDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -593,7 +593,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Exception_AfterDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -618,7 +618,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Canceled_BeforeCreate()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -644,7 +644,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Canceled_BeforeSubscribe()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -670,7 +670,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Canceled_BeforeDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -696,7 +696,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Canceled_AfterDispose()
         {
             var taskScheduler = new TestTaskScheduler();
@@ -722,7 +722,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR
-        [TestMethod]
+        [Fact]
         public void TaskToObservable_Void_Scheduler()
         {
             var e = new ManualResetEvent(false);
@@ -741,7 +741,7 @@ namespace ReactiveTests.Tests
 
             e.WaitOne();
 
-            Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, t);
+            Assert.Equal(Thread.CurrentThread.ManagedThreadId, t);
         }
 #endif
 
@@ -749,7 +749,7 @@ namespace ReactiveTests.Tests
 
         #region ToTask
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTask_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => TaskObservableExtensions.ToTask<int>(null));
@@ -758,7 +758,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => TaskObservableExtensions.ToTask<int>(null, new CancellationToken(), new object()));
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTaskNoValue()
         {
             var scheduler = new TestScheduler();
@@ -768,13 +768,13 @@ namespace ReactiveTests.Tests
             var continuation = xs.ToTask();
             scheduler.Start();
 
-            Assert.IsTrue(continuation.IsFaulted);
-            Assert.IsTrue(continuation.Exception.InnerExceptions.Count == 1 && continuation.Exception.InnerExceptions[0] is InvalidOperationException);
+            Assert.True(continuation.IsFaulted);
+            Assert.True(continuation.Exception.InnerExceptions.Count == 1 && continuation.Exception.InnerExceptions[0] is InvalidOperationException);
 
-            Assert.AreEqual(1, scheduler.Clock);
+            Assert.Equal(1, scheduler.Clock);
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTaskSingleValue()
         {
             var scheduler = new TestScheduler();
@@ -784,13 +784,13 @@ namespace ReactiveTests.Tests
             var continuation = xs.ToTask();
             scheduler.Start();
 
-            Assert.IsTrue(continuation.IsCompleted);
-            Assert.AreEqual(5, continuation.Result);
+            Assert.True(continuation.IsCompleted);
+            Assert.Equal(5, continuation.Result);
 
-            Assert.AreEqual(1, scheduler.Clock);
+            Assert.Equal(1, scheduler.Clock);
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTaskMultipleValues()
         {
             var scheduler = new TestScheduler();
@@ -805,15 +805,15 @@ namespace ReactiveTests.Tests
             var continuation = xs.ToTask();
             scheduler.Start();
 
-            Assert.IsTrue(continuation.IsCompleted);
-            Assert.AreEqual(3, continuation.Result);
+            Assert.True(continuation.IsCompleted);
+            Assert.Equal(3, continuation.Result);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(0, 200)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTaskException()
         {
             var scheduler = new TestScheduler();
@@ -829,18 +829,18 @@ namespace ReactiveTests.Tests
             var continuation = xs.ToTask();
             scheduler.Start();
 
-            Assert.IsTrue(continuation.IsFaulted);
+            Assert.True(continuation.IsFaulted);
             var ag = continuation.Exception;
-            Assert.IsNotNull(ag);
-            Assert.AreEqual(1, ag.InnerExceptions.Count);
-            Assert.AreEqual(ex, ag.InnerExceptions[0]);
+            Assert.NotNull(ag);
+            Assert.Equal(1, ag.InnerExceptions.Count);
+            Assert.Equal(ex, ag.InnerExceptions[0]);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(0, 200)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTaskCancelled()
         {
             var scheduler = new TestScheduler();
@@ -857,14 +857,14 @@ namespace ReactiveTests.Tests
 
             scheduler.Start();
 
-            Assert.IsTrue(continuation.IsCanceled);
+            Assert.True(continuation.IsCanceled);
 
             xs.Subscriptions.AssertEqual(
                 Subscribe(0, 125)
             );
         }
 
-        [TestMethod]
+        [Fact]
         public void ObservableToTaskWithStateSingleValue()
         {
             var state = "bar";
@@ -874,14 +874,14 @@ namespace ReactiveTests.Tests
             var xs = Observable.Return(5, scheduler);
             
             var continuation = xs.ToTask(state);
-            Assert.AreSame(continuation.AsyncState, state);
+            Assert.Same(continuation.AsyncState, state);
             
             scheduler.Start();
 
-            Assert.IsTrue(continuation.IsCompleted);
-            Assert.AreEqual(5, continuation.Result);
+            Assert.True(continuation.IsCompleted);
+            Assert.Equal(5, continuation.Result);
 
-            Assert.AreEqual(1, scheduler.Clock);
+            Assert.Equal(1, scheduler.Clock);
         }
 
         #endregion

Rx.NET/Source/Tests.System.Reactive/Tests/TimeTests.cs

@@ -2,168 +2,168 @@
 
 using System;
 using System.Reactive;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class TimeTests
     {
-        [TestMethod]
+        [Fact]
         public void TimeInterval_Ctor_Properties()
         {
             var ti = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.45));
-            Assert.AreEqual(42, ti.Value);
-            Assert.AreEqual(TimeSpan.FromSeconds(123.45), ti.Interval);
+            Assert.Equal(42, ti.Value);
+            Assert.Equal(TimeSpan.FromSeconds(123.45), ti.Interval);
         }
 
-        [TestMethod]
+        [Fact]
         public void TimeInterval_Equals()
         {
             var ti = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.45));
-            Assert.IsFalse(ti.Equals("x"));
-            Assert.IsFalse(((object)ti).Equals("x"));
-            Assert.IsTrue(ti.Equals(ti));
-            Assert.IsTrue(((object)ti).Equals(ti));
+            Assert.False(ti.Equals("x"));
+            Assert.False(((object)ti).Equals("x"));
+            Assert.True(ti.Equals(ti));
+            Assert.True(((object)ti).Equals(ti));
 
             var t2 = new TimeInterval<int>(43, TimeSpan.FromSeconds(123.45));
-            Assert.IsFalse(ti.Equals(t2));
-            Assert.IsFalse(((object)ti).Equals(t2));
+            Assert.False(ti.Equals(t2));
+            Assert.False(((object)ti).Equals(t2));
 
             var t3 = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.56));
-            Assert.IsFalse(ti.Equals(t3));
-            Assert.IsFalse(((object)ti).Equals(t3));
+            Assert.False(ti.Equals(t3));
+            Assert.False(((object)ti).Equals(t3));
 
             var t4 = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.45));
-            Assert.IsTrue(ti.Equals(t4));
-            Assert.IsTrue(((object)ti).Equals(t4));
+            Assert.True(ti.Equals(t4));
+            Assert.True(((object)ti).Equals(t4));
         }
 
-        [TestMethod]
+        [Fact]
         public void TimeInterval_GetHashCode()
         {
             var ti = new TimeInterval<string>(null, TimeSpan.FromSeconds(123.45));
-            Assert.IsTrue(ti.GetHashCode() != 0);
-            Assert.AreEqual(ti.GetHashCode(), ti.GetHashCode());
+            Assert.True(ti.GetHashCode() != 0);
+            Assert.Equal(ti.GetHashCode(), ti.GetHashCode());
 
             var t2 = new TimeInterval<string>("", TimeSpan.FromSeconds(123.45));
-            Assert.AreNotEqual(ti.GetHashCode(), t2.GetHashCode());
+            Assert.NotEqual(ti.GetHashCode(), t2.GetHashCode());
         }
 
-        [TestMethod]
+        [Fact]
         public void TimeInterval_EqualsOperators()
         {
             var ti = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.45));
             var t2 = new TimeInterval<int>(43, TimeSpan.FromSeconds(123.45));
-            Assert.IsFalse(ti == t2);
-            Assert.IsFalse(t2 == ti);
-            Assert.IsTrue(ti != t2);
-            Assert.IsTrue(t2 != ti);
+            Assert.False(ti == t2);
+            Assert.False(t2 == ti);
+            Assert.True(ti != t2);
+            Assert.True(t2 != ti);
 
             var t3 = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.56));
-            Assert.IsFalse(ti == t3);
-            Assert.IsFalse(t3 == ti);
-            Assert.IsTrue(ti != t3);
-            Assert.IsTrue(t3 != ti);
+            Assert.False(ti == t3);
+            Assert.False(t3 == ti);
+            Assert.True(ti != t3);
+            Assert.True(t3 != ti);
 
             var t4 = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.45));
-            Assert.IsTrue(ti == t4);
-            Assert.IsTrue(t4 == ti);
-            Assert.IsFalse(ti != t4);
-            Assert.IsFalse(t4 != ti);
+            Assert.True(ti == t4);
+            Assert.True(t4 == ti);
+            Assert.False(ti != t4);
+            Assert.False(t4 != ti);
         }
 
-        [TestMethod]
+        [Fact]
         public void TimeInterval_ToString()
         {
             var ti = new TimeInterval<int>(42, TimeSpan.FromSeconds(123.45));
-            Assert.IsTrue(ti.ToString().Contains(42.ToString()));
-            Assert.IsTrue(ti.ToString().Contains(TimeSpan.FromSeconds(123.45).ToString()));
+            Assert.True(ti.ToString().Contains(42.ToString()));
+            Assert.True(ti.ToString().Contains(TimeSpan.FromSeconds(123.45).ToString()));
         }
 
-        [TestMethod]
+        [Fact]
         public void Timestamped_Create()
         {
             var o = DateTimeOffset.UtcNow;
             var ti = Timestamped.Create(42, o);
-            Assert.AreEqual(42, ti.Value);
-            Assert.AreEqual(o, ti.Timestamp);
+            Assert.Equal(42, ti.Value);
+            Assert.Equal(o, ti.Timestamp);
         }
 
-        [TestMethod]
+        [Fact]
         public void Timestamped_Ctor_Properties()
         {
             var o = new DateTimeOffset();
             var ti = new Timestamped<int>(42, o);
-            Assert.AreEqual(42, ti.Value);
-            Assert.AreEqual(o, ti.Timestamp);
+            Assert.Equal(42, ti.Value);
+            Assert.Equal(o, ti.Timestamp);
         }
 
-        [TestMethod]
+        [Fact]
         public void Timestamped_Equals()
         {
             var ti = new Timestamped<int>(42, new DateTimeOffset());
-            Assert.IsFalse(ti.Equals("x"));
-            Assert.IsFalse(((object)ti).Equals("x"));
-            Assert.IsTrue(ti.Equals(ti));
-            Assert.IsTrue(((object)ti).Equals(ti));
+            Assert.False(ti.Equals("x"));
+            Assert.False(((object)ti).Equals("x"));
+            Assert.True(ti.Equals(ti));
+            Assert.True(((object)ti).Equals(ti));
 
             var t2 = new Timestamped<int>(43, new DateTimeOffset());
-            Assert.IsFalse(ti.Equals(t2));
-            Assert.IsFalse(((object)ti).Equals(t2));
+            Assert.False(ti.Equals(t2));
+            Assert.False(((object)ti).Equals(t2));
 
             var t3 = new Timestamped<int>(42, new DateTimeOffset().AddDays(1));
-            Assert.IsFalse(ti.Equals(t3));
-            Assert.IsFalse(((object)ti).Equals(t3));
+            Assert.False(ti.Equals(t3));
+            Assert.False(((object)ti).Equals(t3));
 
             var t4 = new Timestamped<int>(42, new DateTimeOffset());
-            Assert.IsTrue(ti.Equals(t4));
-            Assert.IsTrue(((object)ti).Equals(t4));
+            Assert.True(ti.Equals(t4));
+            Assert.True(((object)ti).Equals(t4));
         }
 
-        [TestMethod]
+        [Fact]
         public void Timestamped_GetHashCode()
         {
             var ti = new Timestamped<string>(null, new DateTimeOffset());
-            Assert.IsTrue(ti.GetHashCode() != 0);
-            Assert.AreEqual(ti.GetHashCode(), ti.GetHashCode());
+            Assert.True(ti.GetHashCode() != 0);
+            Assert.Equal(ti.GetHashCode(), ti.GetHashCode());
 
             var t2 = new Timestamped<string>("", new DateTimeOffset());
-            Assert.AreNotEqual(ti.GetHashCode(), t2.GetHashCode());
+            Assert.NotEqual(ti.GetHashCode(), t2.GetHashCode());
         }
 
-        [TestMethod]
+        [Fact]
         public void Timestamped_EqualsOperators()
         {
             var o = new DateTimeOffset();
 
             var ti = new Timestamped<int>(42, o);
             var t2 = new Timestamped<int>(43, o);
-            Assert.IsFalse(ti == t2);
-            Assert.IsFalse(t2 == ti);
-            Assert.IsTrue(ti != t2);
-            Assert.IsTrue(t2 != ti);
+            Assert.False(ti == t2);
+            Assert.False(t2 == ti);
+            Assert.True(ti != t2);
+            Assert.True(t2 != ti);
 
             var t3 = new Timestamped<int>(42, o.AddDays(1));
-            Assert.IsFalse(ti == t3);
-            Assert.IsFalse(t3 == ti);
-            Assert.IsTrue(ti != t3);
-            Assert.IsTrue(t3 != ti);
+            Assert.False(ti == t3);
+            Assert.False(t3 == ti);
+            Assert.True(ti != t3);
+            Assert.True(t3 != ti);
 
             var t4 = new Timestamped<int>(42, o);
-            Assert.IsTrue(ti == t4);
-            Assert.IsTrue(t4 == ti);
-            Assert.IsFalse(ti != t4);
-            Assert.IsFalse(t4 != ti);
+            Assert.True(ti == t4);
+            Assert.True(t4 == ti);
+            Assert.False(ti != t4);
+            Assert.False(t4 != ti);
         }
 
-        [TestMethod]
+        [Fact]
         public void Timestamped_ToString()
         {
             var o = new DateTimeOffset();
             var ti = new Timestamped<int>(42, o);
-            Assert.IsTrue(ti.ToString().Contains(42.ToString()));
-            Assert.IsTrue(ti.ToString().Contains(o.ToString()));
+            Assert.True(ti.ToString().Contains(42.ToString()));
+            Assert.True(ti.ToString().Contains(o.ToString()));
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/UnitTest.cs

@@ -1,25 +1,25 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
 
 using System.Reactive;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ReactiveTests.Tests
 {
-    [TestClass]
+    
     public class UnitTest
     {
-        [TestMethod]
+        [Fact]
         public void Unit()
         {
             var u1 = new Unit();
             var u2 = new Unit();
-            Assert.IsTrue(u1.Equals(u2));
-            Assert.IsFalse(u1.Equals(""));
-            Assert.IsFalse(u1.Equals(null));
-            Assert.IsTrue(u1 == u2);
-            Assert.IsFalse(u1 != u2);
-            Assert.AreEqual(0, u1.GetHashCode());
-            Assert.AreEqual("()", u1.ToString());
+            Assert.True(u1.Equals(u2));
+            Assert.False(u1.Equals(""));
+            Assert.False(u1.Equals(null));
+            Assert.True(u1 == u2);
+            Assert.False(u1 != u2);
+            Assert.Equal(0, u1.GetHashCode());
+            Assert.Equal("()", u1.ToString());
         }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Utils.cs

@@ -2,6 +2,7 @@
 
 using System.Linq;
 using System.Reactive.Subjects;
+using System.Reflection;
 using System.Runtime.Versioning;
 
 namespace ReactiveTests
@@ -14,7 +15,7 @@ namespace ReactiveTests
             return false;
 #else
 
-            var a = typeof(ISubject<int>).Assembly.GetCustomAttributes(typeof(TargetFrameworkAttribute), false).Cast<TargetFrameworkAttribute>().SingleOrDefault();
+            var a = typeof(ISubject<int>).GetTypeInfo().Assembly.GetCustomAttributes<TargetFrameworkAttribute>().SingleOrDefault();
             return a != null && a.FrameworkDisplayName == ".NET Portable Subset";
 #endif
         }

Rx.NET/Source/Tests.System.Reactive/project.json

@@ -0,0 +1,85 @@
+{
+  "version": "3.0.0-*",
+  "title": "Reactive Extensions - Core Library",
+  "description": "Reactive Extensions Core Library containing base classes and scheduler infrastructure.",
+  "authors": [ "Microsoft" ],
+  "copyright": "Copyright (C) Microsoft Corporation",
+  "tags": [ "Rx", "Reactive", "Extensions", "Observable", "LINQ", "Events" ],
+  "iconUrl": "http://go.microsoft.com/fwlink/?LinkId=261274",
+  "projectUrl": "http://go.microsoft.com/fwlink/?LinkId=261273",
+  "licenseUrl": "http://go.microsoft.com/fwlink/?LinkID=261272",
+  "requireLicenseAcceptance": true,
+  
+  "dependencies": {
+    "System.Reactive.Interfaces": { "target": "project" },
+    "System.Reactive.Linq": { "target": "project" },
+    "System.Reactive.PlatformServices": { "target": "project" },
+    "Microsoft.Reactive.Testing": { "target": "project" },
+    "System.Reactive.Experimental": { "target": "project" },
+    "System.Reactive.Providers": { "target": "project" }, 
+    "System.Reactive.Observable.Aliases": {"target": "project"}, 
+    "xunit": "2.1.0"
+  },
+  
+  "frameworks": {
+    "net45": {
+      "compilationOptions": {
+        "define": [
+            "NO_EVENTARGS_CONSTRAINT",
+            "HAS_EDI",
+            "HAS_WINRT",
+            "HAS_PROGRESS",
+            "PREFER_ASYNC",
+            "HAS_AWAIT",
+            "HAS_APTCA",
+            "HAS_DISPATCHER",
+            "HAS_DISPATCHER_PRIORITY",
+            "HAS_STACKTRACE",
+            "HAS_WINFORMS",
+            "USE_TIMER_SELF_ROOT"
+        ]
+      },
+      "dependencies": {
+        "System.Reactive.Windows.Threading": { "target": "project" },
+        "System.Reactive.Windows.Forms": { "target": "project" },
+        "System.Reactive.Runtime.Remoting": { "target": "project" }        
+      },
+      "frameworkAssemblies": {
+        "System.Windows": "4.0.0.0",
+        "WindowsBase": "4.0.0.0",
+        "System.Runtime": "4.0.0.0",
+        "System.Threading.Tasks": "4.0.0.0"
+      }
+    },
+    "dotnet5.1": {
+      "compilationOptions": {
+        "define": [
+            "NO_EVENTARGS_CONSTRAINT",
+            "HAS_EDI",
+            "HAS_WINRT",
+            "HAS_PROGRESS",
+            "PREFER_ASYNC",
+            "HAS_AWAIT",
+            "HAS_APTCA",
+            "NO_REMOTING",
+            "NO_SERIALIZABLE",
+            "NO_THREAD",
+            "CRIPPLED_REFLECTION",
+            "PLIB",
+            "USE_TIMER_SELF_ROOT"
+        ]
+      },
+      "dependencies": {
+        "System.Collections.Concurrent": "4.0.0",
+        "System.Linq": "4.0.0",
+        "System.Threading": "4.0.0",
+        "System.Threading.Tasks": "4.0.0",
+        "System.Threading.Timer": "4.0.0",
+        "System.Runtime": "4.0.0",
+        "System.Runtime.Extensions": "4.0.0",
+        "System.Reflection": "4.0.0",        
+        "System.Reflection.Extensions": "4.0.0"
+      }
+    }
+  }
+}