Replace xUnit with mstest (#1883)

xUnit is no longer able to run tests on UWP. MSTest supports this in Visual Studio 2022, so we are moving back to MSTest. (Rx used to used MSTest before, so this was a relatively straightforward change.)

We had to make a few changes due to the fact that xUnit supplies a SynchronizationContext whereas MSTest does not.

Also fixed a race condition in CreateAsyncTest.

AsyncRx.NET/Directory.build.props

@@ -31,7 +31,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(IsTestProject)' == 'true'">
-    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
   </ItemGroup>
 
 </Project>

Ix.NET/Source/Directory.Build.props

@@ -34,7 +34,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(IsTestProject)' == 'true'">
-    <PackageReference Include="coverlet.collector" Version="3.1.1" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
   </ItemGroup>
 
 

Rx.NET/Integration/LinuxTests/LinuxTests.csproj

@@ -24,11 +24,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="System.Reactive" Version="5.1.0-preview*" />
-    <PackageReference Include="Microsoft.Reactive.Testing" Version="5.1.0-preview*" />
-    <PackageReference Include="System.Reactive.Observable.Aliases" Version="5.1.0-preview*" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
+    <PackageReference Include="xunit.assert" Version="2.4.2" />
+    <PackageReference Include="System.Reactive" Version="6.0.0-preview*" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="6.0.0-preview*" />
+    <PackageReference Include="System.Reactive.Observable.Aliases" Version="6.0.0-preview*" />
   </ItemGroup>
 </Project>

Rx.NET/Integration/WindowsDesktopTests/WindowsDesktopTests.csproj

@@ -23,11 +23,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="System.Reactive" Version="5.1.0-preview*" />
-    <PackageReference Include="Microsoft.Reactive.Testing" Version="5.1.0-preview*" />
-    <PackageReference Include="System.Reactive.Observable.Aliases" Version="5.1.0-preview*" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
+    <PackageReference Include="xunit.assert" Version="2.4.2" />
+    <PackageReference Include="System.Reactive" Version="6.0.0-preview*" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="6.0.0-preview*" />
+    <PackageReference Include="System.Reactive.Observable.Aliases" Version="6.0.0-preview*" />
   </ItemGroup>
 </Project>

Rx.NET/Source/CodeCoverage.runsettings

@@ -13,4 +13,7 @@
       </DataCollector>
     </DataCollectors>
   </DataCollectionRunSettings>
+  <MSTest>
+    <TestTimeout>120000</TestTimeout>
+  </MSTest>
 </RunSettings>

Rx.NET/Source/Directory.build.props

@@ -36,7 +36,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(IsTestProject)' == 'true'">
-    <PackageReference Include="coverlet.collector" Version="3.1.1" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
   </ItemGroup>
 
 </Project>

Rx.NET/Source/src/Microsoft.Reactive.Testing/IAssertionException.cs

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT License.
+// See the LICENSE file in the project root for more information. 
+
+namespace Xunit.Sdk
+{
+    /// <summary>
+    /// Marker interface required by xUnit.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The <c>xunit.assert.source</c> package normally includes this. However, unlike all the
+    /// other types that package adds to our project, this one type is declared to be
+    /// unconditionally public.
+    /// </para>
+    /// <para>
+    /// We think this might be a bug: https://github.com/xunit/xunit/issues/2703
+    /// </para>
+    /// <para>
+    /// In any case, we do not want our library to be exporting public types in the Xunit.Sdk
+    /// namespace. So the csproj file carefully excludes the Asserts/Sdk/IAssertionException.cs
+    /// file supplied by the package (which defines this type as <c>public</c>), and this file
+    /// supplies an equivalent but <c>internal</c> definition.
+    /// </para>
+    /// </remarks>
+    internal interface IAssertionException
+    {
+    }
+}

Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj

@@ -8,12 +8,19 @@
     <PackageTags>Rx;Reactive;Extensions;Observable;LINQ;Events</PackageTags>    
     <Description>Reactive Extensions (Rx) for .NET - Testing Library</Description>
     <!-- NB: A lot of CA warnings are disabled because of the .cs files included from xunit.assert.source. -->
-    <NoWarn>$(NoWarn);CA1305;CA1307;CA1032;CA1064;CA1822;CA1812</NoWarn>
+    <NoWarn>$(NoWarn);IDE0054;IDE0066;CA1305;CA1307;CA1032;CA1064;CA1822;CA1812;CA1823</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
     <EmbeddedResource Include="Properties\*.xml" />
-    <PackageReference Include="xunit.assert.source" Version="2.4.1" PrivateAssets="All" /> 
+    <PackageReference Include="xunit.assert.source" Version="2.4.2" PrivateAssets="All" /> 
     <ProjectReference Include="..\System.Reactive\System.Reactive.csproj" />
   </ItemGroup>
+
+  <ItemGroup>
+    <!--
+    Workaround for https://github.com/xunit/xunit/issues/2703
+    -->
+    <Compile Remove="$(NuGetPackageRoot)xunit.assert.source\**\contentFiles\cs\**\Asserts\Sdk\IAssertionException.cs" />
+  </ItemGroup>
 </Project>

Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs

@@ -1,4 +1,4 @@
-[assembly: System.CLSCompliant(true)]
+[assembly: System.CLSCompliant(true)]
 [assembly: System.Resources.NeutralResourcesLanguage("en-US")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Tests.System.Reactive, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Tests.System.Reactive.Uwp.DeviceRunner, PublicKey=00240000048000009400000006020000002400005253413100040000010001008f5cff058631087031f8350f30a36fa078027e5df2316b564352dc9eb7af7ce856016d3c5e9d058036fe73bb5c83987bd3fc0793fbe25d633cc4f37c2bd5f1d717cd2a81661bec08f0971dc6078e17bde372b89005e7738a0ebd501b896ca3e8315270ff64df7809dd912c372df61785a5085b3553b7872e39b1b1cc0ff5a6bc")]
@@ -61,7 +61,7 @@ namespace System.Reactive
         public static bool operator !=(System.Reactive.EventPattern<TSender, TEventArgs> first, System.Reactive.EventPattern<TSender, TEventArgs> second) { }
         public static bool operator ==(System.Reactive.EventPattern<TSender, TEventArgs> first, System.Reactive.EventPattern<TSender, TEventArgs> second) { }
     }
-    [System.AttributeUsage(System.AttributeTargets.Assembly | System.AttributeTargets.Module | System.AttributeTargets.Class | System.AttributeTargets.Struct | System.AttributeTargets.Enum | System.AttributeTargets.Constructor | System.AttributeTargets.Method | System.AttributeTargets.Property | System.AttributeTargets.Field | System.AttributeTargets.Event | System.AttributeTargets.Interface | System.AttributeTargets.Parameter | System.AttributeTargets.Delegate | System.AttributeTargets.ReturnValue | System.AttributeTargets.GenericParameter | System.AttributeTargets.All)]
+    [System.AttributeUsage(System.AttributeTargets.All)]
     [System.Reactive.Experimental]
     public sealed class ExperimentalAttribute : System.Attribute
     {
@@ -850,7 +850,7 @@ namespace System.Reactive.Linq
         System.Reactive.Linq.IQbservable<TResult> CreateQuery<TResult>(System.Linq.Expressions.Expression expression);
     }
     public interface IQbservable<out T> : System.IObservable<T>, System.Reactive.Linq.IQbservable { }
-    [System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.All, Inherited=false)]
+    [System.AttributeUsage(System.AttributeTargets.Class, Inherited=false)]
     public sealed class LocalQueryMethodImplementationTypeAttribute : System.Attribute
     {
         public LocalQueryMethodImplementationTypeAttribute(System.Type targetType) { }
@@ -862,7 +862,7 @@ namespace System.Reactive.Linq
         public static System.IObservable<TAccumulate> Aggregate<TSource, TAccumulate>(this System.IObservable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
         public static System.IObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(this System.IObservable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> accumulator, System.Func<TAccumulate, TResult> resultSelector) { }
         public static System.IObservable<bool> All<TSource>(this System.IObservable<TSource> source, System.Func<TSource, bool> predicate) { }
-        public static System.IObservable<TSource> Amb<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource> Amb<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<TSource> Amb<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> Amb<TSource>(this System.IObservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.Reactive.Joins.Pattern<TLeft, TRight> And<TLeft, TRight>(this System.IObservable<TLeft> left, System.IObservable<TRight> right) { }
@@ -910,7 +910,7 @@ namespace System.Reactive.Linq
         public static System.IObservable<TResult> Case<TValue, TResult>(System.Func<TValue> selector, System.Collections.Generic.IDictionary<TValue, System.IObservable<TResult>> sources, System.Reactive.Concurrency.IScheduler scheduler)
             where TValue :  notnull { }
         public static System.IObservable<TResult> Cast<TResult>(this System.IObservable<object> source) { }
-        public static System.IObservable<TSource> Catch<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource> Catch<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<TSource> Catch<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> Catch<TSource>(this System.IObservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.IObservable<TSource> Catch<TSource, TException>(this System.IObservable<TSource> source, System.Func<TException, System.IObservable<TSource>> handler)
@@ -918,7 +918,7 @@ namespace System.Reactive.Linq
         public static System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>> Chunkify<TSource>(this System.IObservable<TSource> source) { }
         public static System.Collections.Generic.IEnumerable<TResult> Collect<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TResult> newCollector, System.Func<TResult, TSource, TResult> merge) { }
         public static System.Collections.Generic.IEnumerable<TResult> Collect<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TResult> getInitialCollector, System.Func<TResult, TSource, TResult> merge, System.Func<TResult, TResult> getNewCollector) { }
-        public static System.IObservable<System.Collections.Generic.IList<TSource>> CombineLatest<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<System.Collections.Generic.IList<TSource>> CombineLatest<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<System.Collections.Generic.IList<TSource>> CombineLatest<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TResult> CombineLatest<TSource, TResult>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, System.Func<System.Collections.Generic.IList<TSource>, TResult> resultSelector) { }
         public static System.IObservable<TResult> CombineLatest<TSource1, TSource2, TResult>(this System.IObservable<TSource1> first, System.IObservable<TSource2> second, System.Func<TSource1, TSource2, TResult> resultSelector) { }
@@ -969,7 +969,7 @@ namespace System.Reactive.Linq
                     System.IObservable<TSource15> source15,
                     System.IObservable<TSource16> source16,
                     System.Func<TSource1, TSource2, TSource3, TSource4, TSource5, TSource6, TSource7, TSource8, TSource9, TSource10, TSource11, TSource12, TSource13, TSource14, TSource15, TSource16, TResult> resultSelector) { }
-        public static System.IObservable<TSource> Concat<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource> Concat<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<TSource> Concat<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> Concat<TSource>(this System.IObservable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> Concat<TSource>(this System.IObservable<System.Threading.Tasks.Task<TSource>> sources) { }
@@ -1222,11 +1222,11 @@ namespace System.Reactive.Linq
         public static System.IObservable<TResult> Max<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, TResult> selector, System.Collections.Generic.IComparer<TResult> comparer) { }
         public static System.IObservable<System.Collections.Generic.IList<TSource>> MaxBy<TSource, TKey>(this System.IObservable<TSource> source, System.Func<TSource, TKey> keySelector) { }
         public static System.IObservable<System.Collections.Generic.IList<TSource>> MaxBy<TSource, TKey>(this System.IObservable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { }
-        public static System.IObservable<TSource> Merge<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource> Merge<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<TSource> Merge<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> Merge<TSource>(this System.IObservable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> Merge<TSource>(this System.IObservable<System.Threading.Tasks.Task<TSource>> sources) { }
-        public static System.IObservable<TSource> Merge<TSource>(System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource> Merge<TSource>(System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<TSource> Merge<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, int maxConcurrent) { }
         public static System.IObservable<TSource> Merge<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, System.Reactive.Concurrency.IScheduler scheduler) { }
         public static System.IObservable<TSource> Merge<TSource>(this System.IObservable<System.IObservable<TSource>> sources, int maxConcurrent) { }
@@ -1268,7 +1268,7 @@ namespace System.Reactive.Linq
         public static System.IObservable<TSource> ObserveOn<TSource>(this System.IObservable<TSource> source, System.Reactive.Concurrency.IScheduler scheduler) { }
         public static System.IObservable<TSource> ObserveOn<TSource>(this System.IObservable<TSource> source, System.Threading.SynchronizationContext context) { }
         public static System.IObservable<TResult> OfType<TResult>(this System.IObservable<object> source) { }
-        public static System.IObservable<TSource> OnErrorResumeNext<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource> OnErrorResumeNext<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<TSource> OnErrorResumeNext<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TSource> OnErrorResumeNext<TSource>(this System.IObservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.IObservable<TSource> Prepend<TSource>(this System.IObservable<TSource> source, TSource value) { }
@@ -1559,7 +1559,7 @@ namespace System.Reactive.Linq
         public static System.IObservable<TResult> Using<TResult, TResource>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResource>> resourceFactoryAsync, System.Func<TResource, System.Threading.CancellationToken, System.Threading.Tasks.Task<System.IObservable<TResult>>> observableFactoryAsync)
             where TResource : System.IDisposable { }
         public static TSource Wait<TSource>(this System.IObservable<TSource> source) { }
-        public static System.IObservable<TResult> When<TResult>(params System.Reactive.Joins.Plan<>[] plans) { }
+        public static System.IObservable<TResult> When<TResult>(params System.Reactive.Joins.Plan<TResult>[] plans) { }
         public static System.IObservable<TResult> When<TResult>(this System.Collections.Generic.IEnumerable<System.Reactive.Joins.Plan<TResult>> plans) { }
         public static System.IObservable<TSource> Where<TSource>(this System.IObservable<TSource> source, System.Func<TSource, bool> predicate) { }
         public static System.IObservable<TSource> Where<TSource>(this System.IObservable<TSource> source, System.Func<TSource, int, bool> predicate) { }
@@ -1576,7 +1576,7 @@ namespace System.Reactive.Linq
         public static System.IObservable<System.IObservable<TSource>> Window<TSource, TWindowBoundary>(this System.IObservable<TSource> source, System.IObservable<TWindowBoundary> windowBoundaries) { }
         public static System.IObservable<System.IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(this System.IObservable<TSource> source, System.IObservable<TWindowOpening> windowOpenings, System.Func<TWindowOpening, System.IObservable<TWindowClosing>> windowClosingSelector) { }
         public static System.IObservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this System.IObservable<TFirst> first, System.IObservable<TSecond> second, System.Func<TFirst, TSecond, TResult> resultSelector) { }
-        public static System.IObservable<System.Collections.Generic.IList<TSource>> Zip<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<System.Collections.Generic.IList<TSource>> Zip<TSource>(params System.IObservable<TSource>[] sources) { }
         public static System.IObservable<System.Collections.Generic.IList<TSource>> Zip<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         public static System.IObservable<TResult> Zip<TSource, TResult>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, System.Func<System.Collections.Generic.IList<TSource>, TResult> resultSelector) { }
         public static System.IObservable<TResult> Zip<TSource1, TSource2, TResult>(this System.IObservable<TSource1> first, System.Collections.Generic.IEnumerable<TSource2> second, System.Func<TSource1, TSource2, TResult> resultSelector) { }
@@ -1690,7 +1690,7 @@ namespace System.Reactive.Linq
         [System.Reactive.Experimental]
         public static System.IObservable<TSource> Expand<TSource>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TSource>> selector, System.Reactive.Concurrency.IScheduler scheduler) { }
         [System.Reactive.Experimental]
-        public static System.IObservable<TSource[]> ForkJoin<TSource>(params System.IObservable<>[] sources) { }
+        public static System.IObservable<TSource[]> ForkJoin<TSource>(params System.IObservable<TSource>[] sources) { }
         [System.Reactive.Experimental]
         public static System.IObservable<TSource[]> ForkJoin<TSource>(this System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         [System.Reactive.Experimental]
@@ -1771,7 +1771,7 @@ namespace System.Reactive.Linq
         public static System.Reactive.Linq.IQbservable<TResult> Aggregate<TSource, TAccumulate, TResult>(this System.Reactive.Linq.IQbservable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> accumulator, System.Linq.Expressions.Expression<System.Func<TAccumulate, TResult>> resultSelector) { }
         public static System.Reactive.Linq.IQbservable<bool> All<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
         public static System.Reactive.Linq.IQbservable<TSource> Amb<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<TSource> Amb<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource> Amb<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Amb<TSource>(this System.Reactive.Linq.IQbservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.Reactive.Joins.QueryablePattern<TLeft, TRight> And<TLeft, TRight>(this System.Reactive.Linq.IQbservable<TLeft> left, System.IObservable<TRight> right) { }
         public static System.Reactive.Linq.IQbservable<bool> Any<TSource>(this System.Reactive.Linq.IQbservable<TSource> source) { }
@@ -1820,7 +1820,7 @@ namespace System.Reactive.Linq
             where TValue :  notnull { }
         public static System.Reactive.Linq.IQbservable<TResult> Cast<TResult>(this System.Reactive.Linq.IQbservable<object> source) { }
         public static System.Reactive.Linq.IQbservable<TSource> Catch<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<TSource> Catch<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource> Catch<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Catch<TSource>(this System.Reactive.Linq.IQbservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.Reactive.Linq.IQbservable<TSource> Catch<TSource, TException>(this System.Reactive.Linq.IQbservable<TSource> source, System.Linq.Expressions.Expression<System.Func<TException, System.IObservable<TSource>>> handler)
             where TException : System.Exception { }
@@ -1828,7 +1828,7 @@ namespace System.Reactive.Linq
         public static System.Linq.IQueryable<TResult> Collect<TSource, TResult>(this System.Reactive.Linq.IQbservable<TSource> source, System.Linq.Expressions.Expression<System.Func<TResult>> newCollector, System.Linq.Expressions.Expression<System.Func<TResult, TSource, TResult>> merge) { }
         public static System.Linq.IQueryable<TResult> Collect<TSource, TResult>(this System.Reactive.Linq.IQbservable<TSource> source, System.Linq.Expressions.Expression<System.Func<TResult>> getInitialCollector, System.Linq.Expressions.Expression<System.Func<TResult, TSource, TResult>> merge, System.Linq.Expressions.Expression<System.Func<TResult, TResult>> getNewCollector) { }
         public static System.Reactive.Linq.IQbservable<System.Collections.Generic.IList<TSource>> CombineLatest<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<System.Collections.Generic.IList<TSource>> CombineLatest<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<System.Collections.Generic.IList<TSource>> CombineLatest<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TResult> CombineLatest<TSource, TResult>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, System.Linq.Expressions.Expression<System.Func<System.Collections.Generic.IList<TSource>, TResult>> resultSelector) { }
         public static System.Reactive.Linq.IQbservable<TResult> CombineLatest<TSource1, TSource2, TResult>(this System.Reactive.Linq.IQbservable<TSource1> first, System.IObservable<TSource2> second, System.Linq.Expressions.Expression<System.Func<TSource1, TSource2, TResult>> resultSelector) { }
         public static System.Reactive.Linq.IQbservable<TResult> CombineLatest<TSource1, TSource2, TSource3, TResult>(this System.Reactive.Linq.IQbservable<TSource1> source1, System.IObservable<TSource2> source2, System.IObservable<TSource3> source3, System.Linq.Expressions.Expression<System.Func<TSource1, TSource2, TSource3, TResult>> resultSelector) { }
@@ -1881,7 +1881,7 @@ namespace System.Reactive.Linq
         public static System.Reactive.Linq.IQbservable<TSource> Concat<TSource>(this System.Reactive.Linq.IQbservable<System.IObservable<TSource>> sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Concat<TSource>(this System.Reactive.Linq.IQbservable<System.Threading.Tasks.Task<TSource>> sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Concat<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<TSource> Concat<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource> Concat<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Concat<TSource>(this System.Reactive.Linq.IQbservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.Reactive.Linq.IQbservable<bool> Contains<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, TSource value) { }
         public static System.Reactive.Linq.IQbservable<bool> Contains<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource> comparer) { }
@@ -2073,12 +2073,12 @@ namespace System.Reactive.Linq
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservable<System.IObservable<TSource>> sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservable<System.Threading.Tasks.Task<TSource>> sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservable<System.IObservable<TSource>> sources, int maxConcurrent) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, int maxConcurrent) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, System.Reactive.Concurrency.IScheduler scheduler) { }
-        public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservable<TSource> first, System.IObservable<TSource> second, System.Reactive.Concurrency.IScheduler scheduler) { }
         public static System.Reactive.Linq.IQbservable<TSource> Merge<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, int maxConcurrent, System.Reactive.Concurrency.IScheduler scheduler) { }
         public static System.Reactive.Linq.IQbservable<decimal> Min(this System.Reactive.Linq.IQbservable<decimal> source) { }
@@ -2116,7 +2116,7 @@ namespace System.Reactive.Linq
         public static System.Reactive.Linq.IQbservable<TSource> ObserveOn<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, System.Threading.SynchronizationContext context) { }
         public static System.Reactive.Linq.IQbservable<TResult> OfType<TResult>(this System.Reactive.Linq.IQbservable<object> source) { }
         public static System.Reactive.Linq.IQbservable<TSource> OnErrorResumeNext<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<TSource> OnErrorResumeNext<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource> OnErrorResumeNext<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TSource> OnErrorResumeNext<TSource>(this System.Reactive.Linq.IQbservable<TSource> first, System.IObservable<TSource> second) { }
         public static System.Reactive.Linq.IQbservable<TSource> Prepend<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, TSource value) { }
         public static System.Reactive.Linq.IQbservable<TSource> Prepend<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, TSource value, System.Reactive.Concurrency.IScheduler scheduler) { }
@@ -2380,7 +2380,7 @@ namespace System.Reactive.Linq
         public static System.Reactive.Linq.IQbservable<TResult> Using<TResult, TResource>(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression<System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResource>>> resourceFactoryAsync, System.Linq.Expressions.Expression<System.Func<TResource, System.Threading.CancellationToken, System.Threading.Tasks.Task<System.IObservable<TResult>>>> observableFactoryAsync)
             where TResource : System.IDisposable { }
         public static System.Reactive.Linq.IQbservable<TResult> When<TResult>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.Reactive.Joins.QueryablePlan<TResult>> plans) { }
-        public static System.Reactive.Linq.IQbservable<TResult> When<TResult>(this System.Reactive.Linq.IQbservableProvider provider, params System.Reactive.Joins.QueryablePlan<>[] plans) { }
+        public static System.Reactive.Linq.IQbservable<TResult> When<TResult>(this System.Reactive.Linq.IQbservableProvider provider, params System.Reactive.Joins.QueryablePlan<TResult>[] plans) { }
         public static System.Reactive.Linq.IQbservable<TSource> Where<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { }
         public static System.Reactive.Linq.IQbservable<TSource> Where<TSource>(this System.Reactive.Linq.IQbservable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { }
         public static System.Reactive.Linq.IQbservable<TSource> While<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression<System.Func<bool>> condition, System.IObservable<TSource> source) { }
@@ -2397,7 +2397,7 @@ namespace System.Reactive.Linq
         public static System.Reactive.Linq.IQbservable<System.IObservable<TSource>> Window<TSource, TWindowOpening, TWindowClosing>(this System.Reactive.Linq.IQbservable<TSource> source, System.IObservable<TWindowOpening> windowOpenings, System.Linq.Expressions.Expression<System.Func<TWindowOpening, System.IObservable<TWindowClosing>>> windowClosingSelector) { }
         public static System.Reactive.Linq.IQbservable<TResult> WithLatestFrom<TFirst, TSecond, TResult>(this System.Reactive.Linq.IQbservable<TFirst> first, System.IObservable<TSecond> second, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, TResult>> resultSelector) { }
         public static System.Reactive.Linq.IQbservable<System.Collections.Generic.IList<TSource>> Zip<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
-        public static System.Reactive.Linq.IQbservable<System.Collections.Generic.IList<TSource>> Zip<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<System.Collections.Generic.IList<TSource>> Zip<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         public static System.Reactive.Linq.IQbservable<TResult> Zip<TSource, TResult>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources, System.Linq.Expressions.Expression<System.Func<System.Collections.Generic.IList<TSource>, TResult>> resultSelector) { }
         public static System.Reactive.Linq.IQbservable<TResult> Zip<TSource1, TSource2, TResult>(this System.Reactive.Linq.IQbservable<TSource1> first, System.Collections.Generic.IEnumerable<TSource2> second, System.Linq.Expressions.Expression<System.Func<TSource1, TSource2, TResult>> resultSelector) { }
         public static System.Reactive.Linq.IQbservable<TResult> Zip<TSource1, TSource2, TResult>(this System.Reactive.Linq.IQbservable<TSource1> first, System.IObservable<TSource2> second, System.Linq.Expressions.Expression<System.Func<TSource1, TSource2, TResult>> resultSelector) { }
@@ -2692,7 +2692,7 @@ namespace System.Reactive.Linq
         [System.Reactive.Experimental]
         public static System.Reactive.Linq.IQbservable<TSource[]> ForkJoin<TSource>(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable<System.IObservable<TSource>> sources) { }
         [System.Reactive.Experimental]
-        public static System.Reactive.Linq.IQbservable<TSource[]> ForkJoin<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { }
+        public static System.Reactive.Linq.IQbservable<TSource[]> ForkJoin<TSource>(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<TSource>[] sources) { }
         [System.Reactive.Experimental]
         public static System.Reactive.Linq.IQbservable<TResult> ForkJoin<TSource1, TSource2, TResult>(this System.Reactive.Linq.IQbservable<TSource1> first, System.IObservable<TSource2> second, System.Linq.Expressions.Expression<System.Func<TSource1, TSource2, TResult>> resultSelector) { }
         [System.Reactive.Experimental]
@@ -3152,4 +3152,4 @@ namespace System.Runtime.CompilerServices
             where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { }
         public static System.Runtime.CompilerServices.TaskObservableMethodBuilder<T> Create() { }
     }
-}
+}

Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs

@@ -1,4 +1,4 @@
-[assembly: System.CLSCompliant(true)]
+[assembly: System.CLSCompliant(true)]
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
 [assembly: System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName=".NET Framework 4.7.2")]
 namespace Microsoft.Reactive.Testing
@@ -88,8 +88,8 @@ namespace Microsoft.Reactive.Testing
     {
         public TestScheduler() { }
         protected override long Add(long absolute, long relative) { }
-        public Microsoft.Reactive.Testing.ITestableObservable<T> CreateColdObservable<T>(params Microsoft.Reactive.Testing.Recorded<>[] messages) { }
-        public Microsoft.Reactive.Testing.ITestableObservable<T> CreateHotObservable<T>(params Microsoft.Reactive.Testing.Recorded<>[] messages) { }
+        public Microsoft.Reactive.Testing.ITestableObservable<T> CreateColdObservable<T>(params Microsoft.Reactive.Testing.Recorded<System.Reactive.Notification<T>>[] messages) { }
+        public Microsoft.Reactive.Testing.ITestableObservable<T> CreateHotObservable<T>(params Microsoft.Reactive.Testing.Recorded<System.Reactive.Notification<T>>[] messages) { }
         public Microsoft.Reactive.Testing.ITestableObserver<T> CreateObserver<T>() { }
         public override System.IDisposable ScheduleAbsolute<TState>(TState state, long dueTime, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
         public Microsoft.Reactive.Testing.ITestableObserver<T> Start<T>(System.Func<System.IObservable<T>> create) { }
@@ -98,4 +98,4 @@ namespace Microsoft.Reactive.Testing
         protected override System.DateTimeOffset ToDateTimeOffset(long absolute) { }
         protected override long ToRelative(System.TimeSpan timeSpan) { }
     }
-}
+}

Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.cs

@@ -15,42 +15,44 @@ namespace ReactiveTests.Tests.Api
 {
     public class ApiApprovalTests : VerifyBase
     {
-        private readonly VerifySettings verifySettings;
+        static ApiApprovalTests()
+        {
+            VerifierSettings.OnVerifyMismatch((filePair, message) => DiffPlexReporter.Report(filePair.ReceivedPath, filePair.VerifiedPath, message));
+        }
 
         public ApiApprovalTests()
             : base()
         {
-            verifySettings = new VerifySettings();
-            verifySettings.UseExtension("cs");
-
-            VerifierSettings.OnVerifyMismatch((filePair, message) => DiffPlexReporter.Report(filePair.Received, filePair.Verified, message));
         }
 
         [Fact]
         public Task Core()
         {
             var publicApi = GeneratePublicApi(typeof(System.Reactive.Unit).Assembly);
-            return Verify(publicApi, verifySettings);
+            return Verify(publicApi, "cs");
         }
 
         [Fact]
         public Task Aliases()
         {
             var publicApi = GeneratePublicApi(typeof(System.Reactive.Observable.Aliases.QueryLanguage).Assembly);
-            return Verify(publicApi, verifySettings);
+            return Verify(publicApi, "cs");
         }
 
         [Fact]
         public Task Testing()
         {
             var publicApi = GeneratePublicApi(typeof(Microsoft.Reactive.Testing.TestScheduler).Assembly);
-            return Verify(publicApi, verifySettings);
+            return Verify(publicApi, "cs");
         }
 
         private string GeneratePublicApi(Assembly assembly)
         {
-            var namespacePrefixWhitelist = new[] { "System", "Microsoft" };
-            return Filter(ApiGenerator.GeneratePublicApi(assembly, whitelistedNamespacePrefixes: namespacePrefixWhitelist));
+            ApiGeneratorOptions options = new()
+            {
+                AllowNamespacePrefixes = new[] { "System", "Microsoft" }
+            };
+            return Filter(ApiGenerator.GeneratePublicApi(assembly, options));
         }
 
         private static string Filter(string text)

Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj

@@ -25,12 +25,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
-    <PackageReference Include="Verify.Xunit" Version="14.11.2" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="DiffPlex" Version="1.7.0" />
-    <PackageReference Include="PublicApiGenerator" Version="10.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Verify.Xunit" Version="19.11.2" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
+    <PackageReference Include="DiffPlex" Version="1.7.1" />
+    <PackageReference Include="PublicApiGenerator" Version="11.0.0" />
   </ItemGroup>
 
 </Project>

Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml

@@ -1,7 +1,6 @@
-<ui:RunnerApplication
+<Application
     x:Class="Tests.Reactive.Uwp.DeviceRunner.App"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:ui="using:Xunit.Runners.UI"
     RequestedTheme="Light">
-</ui:RunnerApplication>
+</Application>

Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml.cs

@@ -1,17 +1,93 @@
-using System.Reflection;
-using Xunit.Runners.UI;
+using System;
+using System.Reflection;
+
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+
+
+using Windows.UI.Xaml.Navigation;
 
 namespace Tests.Reactive.Uwp.DeviceRunner
 {
-    public sealed partial class App : RunnerApplication
+    public sealed partial class App : Application
     {
-        protected override void OnInitializeRunner()
+        /// <summary>
+        /// Initializes the singleton application object.  This is the first line of authored code
+        /// executed, and as such is the logical equivalent of main() or WinMain().
+        /// </summary>
+        public App()
+        {
+            this.InitializeComponent();
+            this.Suspending += OnSuspending;
+        }
+
+        /// <summary>
+        /// Invoked when the application is launched normally by the end user.  Other entry points
+        /// will be used such as when the application is launched to open a specific file.
+        /// </summary>
+        /// <param name="e">Details about the launch request and process.</param>
+        protected override void OnLaunched(LaunchActivatedEventArgs e)
+        {
+
+#if DEBUG
+            if (global::System.Diagnostics.Debugger.IsAttached)
+            {
+                this.DebugSettings.EnableFrameRateCounter = true;
+            }
+#endif
+
+            Frame rootFrame = Window.Current.Content as Frame;
+
+            // Do not repeat app initialization when the Window already has content,
+            // just ensure that the window is active
+            if (rootFrame == null)
+            {
+                // Create a Frame to act as the navigation context and navigate to the first page
+                rootFrame = new Frame();
+
+                rootFrame.NavigationFailed += OnNavigationFailed;
+
+                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
+                {
+                    //TODO: Load state from previously suspended application
+                }
+
+                // Place the frame in the current Window
+                Window.Current.Content = rootFrame;
+            }
+
+            Microsoft.VisualStudio.TestPlatform.TestExecutor.UnitTestClient.CreateDefaultUI();
+
+            // Ensure the current window is active
+            Window.Current.Activate();
+
+            Microsoft.VisualStudio.TestPlatform.TestExecutor.UnitTestClient.Run(e.Arguments);
+        }
+
+        /// <summary>
+        /// Invoked when Navigation to a certain page fails
+        /// </summary>
+        /// <param name="sender">The Frame which failed navigation</param>
+        /// <param name="e">Details about the navigation failure</param>
+        void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
+        {
+            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
+        }
+
+        /// <summary>
+        /// Invoked when application execution is being suspended.  Application state is saved
+        /// without knowing whether the application will be terminated or resumed with the contents
+        /// of memory still intact.
+        /// </summary>
+        /// <param name="sender">The source of the suspend request.</param>
+        /// <param name="e">Details about the suspend request.</param>
+        private void OnSuspending(object sender, SuspendingEventArgs e)
         {
-            // tests can be inside the main assembly
-            AddTestAssembly(GetType().GetTypeInfo().Assembly);
-            // otherwise you need to ensure that the test assemblies will 
-            // become part of the app bundle
-            // AddTestAssembly(typeof(PortableTests).GetTypeInfo().Assembly);
+            var deferral = e.SuspendingOperation.GetDeferral();
+            //TODO: Save application state and stop any background activity
+            deferral.Complete();
         }
     }
 }

Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj

@@ -25,7 +25,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\x86\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;NETFX_CORE;WINDOWS_UWP;CODE_ANALYSIS;NO_EVENTARGS_CONSTRAINT;HAS_EDI;HAS_WINRT;HAS_PROGRESS;PREFER_ASYNC;HAS_AWAIT;HAS_APTCA;HAS_TPL46;NO_REMOTING;NO_THREAD;WINDOWS;USE_TIMER_SELF_ROOT</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;NETFX_CORE;WINDOWS_UWP;CODE_ANALYSIS;NO_EVENTARGS_CONSTRAINT;HAS_EDI;HAS_WINRT;HAS_PROGRESS;PREFER_ASYNC;HAS_AWAIT;HAS_APTCA;HAS_TPL46;NO_REMOTING;WINDOWS;USE_TIMER_SELF_ROOT</DefineConstants>
     <NoWarn>;2008;0618</NoWarn>
     <DebugType>full</DebugType>
     <PlatformTarget>x86</PlatformTarget>
@@ -35,7 +35,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
     <OutputPath>bin\x86\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP;CODE_ANALYSIS;NO_EVENTARGS_CONSTRAINT;HAS_EDI;HAS_WINRT;HAS_PROGRESS;PREFER_ASYNC;HAS_AWAIT;HAS_APTCA;HAS_TPL46;NO_REMOTING;NO_THREAD;WINDOWS;USE_TIMER_SELF_ROOT</DefineConstants>
+    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP;CODE_ANALYSIS;NO_EVENTARGS_CONSTRAINT;HAS_EDI;HAS_WINRT;HAS_PROGRESS;PREFER_ASYNC;HAS_AWAIT;HAS_APTCA;HAS_TPL46;NO_REMOTING;WINDOWS;USE_TIMER_SELF_ROOT</DefineConstants>
     <Optimize>true</Optimize>
     <NoWarn>;2008;0618</NoWarn>
     <DebugType>pdbonly</DebugType>
@@ -94,10 +94,11 @@
   <PropertyGroup>
     <NoWarn>$(NoWarn);IDE0003;IDE0016;IDE0017;IDE0018;IDE0019;IDE0020;IDE0031;IDE0032;IDE0034;IDE0037;IDE0038;IDE0039;IDE0040;IDE0044;IDE0051;IDE0052;IDE0056;IDE0057;IDE0059;IDE0060;IDE0062;IDE0063;IDE0071;IDE0074;IDE0075;IDE0076;IDE0077;IDE0079;IDE0083;IDE0090;IDE0180;IDE1006;IDE1056</NoWarn>
   </PropertyGroup>
+  <PropertyGroup>
+    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
+  </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="6.2.13" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.devices" Version="2.5.25" />
+    <SDKReference Include="TestPlatform.Universal, Version=$(UnitTestPlatformVersion)" />
   </ItemGroup>
   <ItemGroup>
     <!-- A reference to the entire .Net Framework and Windows SDK are automatically included -->
@@ -112,6 +113,7 @@
     <Compile Include="..\Tests.System.Reactive\**\*.cs">
       <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
     </Compile>
+    <Compile Remove="..\Tests.System.Reactive\Tests\LicenseHeaderTest.cs" />
     <Compile Remove="..\Tests.System.Reactive\bin\**\*" />
     <Compile Remove="..\Tests.System.Reactive\obj\**\*" />
     <Compile Include="App.xaml.cs">
@@ -134,6 +136,12 @@
     <Content Include="Assets\StoreLogo.png" />
     <Content Include="Assets\Wide310x150Logo.scale-200.png" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="6.2.14" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
+    <PackageReference Include="xunit.assert" Version="2.4.2" />
+  </ItemGroup>
   <ItemGroup>
     <ApplicationDefinition Include="App.xaml">
       <Generator>MSBuild:Compile</Generator>

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

@@ -11,7 +11,7 @@ using System.Reactive.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Stress.Schedulers
 {

Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj

@@ -1,10 +1,11 @@
 <Project Sdk="MSBuild.Sdk.Extras">
+
   <PropertyGroup>
     <TargetFrameworks>net472;net6.0;net7.0;net6.0-windows10.0.19041</TargetFrameworks>
     <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TargetFramework)' == 'net472'">
+  <PropertyGroup Condition="$(TargetFramework.StartsWith('net6.0-windows')) or '$(TargetFramework)' == 'net472'">
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
   </PropertyGroup>
@@ -16,9 +17,21 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />    
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
+    <!--
+    We need to be on a sufficiently recent version of the test framework, because we need this fix:
+      https://github.com/microsoft/testfx/pull/1071
+    Without this, the test runner fails to process Windows-version-specific TFMs for .NET 6.0.
+    Since the various libraries that require net6.0-windows all specify a minimum version (10.0.19041
+    for reasons not currently clear to me; idg10) this test project needs to specify at least as new
+    a version. If we write just net6.0-windows, that turns out to imply Windows 7.0, so it is not
+    considered compatible with a net6.0-windows10.0.19041 library.
+    Before that PR was merged, the test runner wouldn't work if the host specified a TFM with a
+    specific Windows version.
+-->
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
+    <PackageReference Include="xunit.assert" Version="2.4.2" />
     <ProjectReference Include="..\..\src\System.Reactive\System.Reactive.csproj" />
     <ProjectReference Include="..\..\src\System.Reactive.Observable.Aliases\System.Reactive.Observable.Aliases.csproj" />
     <ProjectReference Include="..\..\src\Microsoft.Reactive.Testing\Microsoft.Reactive.Testing.csproj" />

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

@@ -6,14 +6,17 @@ using System.Linq;
 using System.Reactive.Linq;
 using System.Reactive.Observable.Aliases;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
 
+    [TestClass]
     public partial class AliasesTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Qbservable_Aliases()
         {
             var xs = Observable.Return(1).AsQbservable();

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

@@ -5,20 +5,20 @@
 using System;
 using System.Reactive;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class AnonymousTest
     {
-        [Fact]
+        [TestMethod]
         public void AnonymousObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new AnonymousObservable<int>(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void AnonymousObserver_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new AnonymousObserver<int>(default));
@@ -34,7 +34,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new AnonymousObserver<int>(x => { }, ex => { }, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void AnonymousObserver_Error_Null()
         {
             var observer = new AnonymousObserver<int>(_ => { }, e => { }, () => { });

Rx.NET/Source/tests/Tests.System.Reactive/Tests/ArgumentValidationTest.cs

@@ -14,7 +14,7 @@ using System.Reactive.Subjects;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
@@ -22,6 +22,7 @@ namespace ReactiveTests.Tests
     /// Check if the Observable operator methods perform the proper
     /// argument validations en-masse with reflective checks.
     /// </summary>
+    [TestClass]
     public class ArgumentValidationTest
     {
         #region + Default values for the generic types +
@@ -81,7 +82,7 @@ namespace ReactiveTests.Tests
 
                 { "IEnumerable`1[IObservable`1[Int32]]", new[] { Observable.Return(1) } },
 
-                { "SynchronizationContext", SynchronizationContext.Current },
+                { "SynchronizationContext", SynchronizationContext.Current ?? new SynchronizationContext() },
 
                 { "IEqualityComparer`1[Int32]", EqualityComparer<int>.Default },
 
@@ -269,13 +270,13 @@ namespace ReactiveTests.Tests
 
         #endregion
 
-        [Fact]
+        [TestMethod]
         public void Verify_Observable()
         {
             VerifyClass(typeof(Observable));
         }
 
-        [Fact]
+        [TestMethod]
         public void Verify_ObservableEx()
         {
             VerifyClass(typeof(ObservableEx));

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

@@ -4,21 +4,23 @@
 
 using System;
 using System.Reactive.Concurrency;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class AsyncLockTest
     {
-        [Fact]
+        [TestMethod]
         public void Wait_ArgumentChecking()
         {
             var asyncLock = new AsyncLock();
             Assert.Throws<ArgumentNullException>(() => asyncLock.Wait(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Wait_Graceful()
         {
             var ok = false;
@@ -26,7 +28,7 @@ namespace ReactiveTests.Tests
             Assert.True(ok);
         }
 
-        [Fact]
+        [TestMethod]
         public void Wait_Fail()
         {
             var l = new AsyncLock();
@@ -46,7 +48,7 @@ namespace ReactiveTests.Tests
             l.Wait(() => { Assert.True(false); });
         }
 
-        [Fact]
+        [TestMethod]
         public void Wait_QueuesWork()
         {
             var l = new AsyncLock();
@@ -57,7 +59,7 @@ namespace ReactiveTests.Tests
             Assert.True(l2);
         }
 
-        [Fact]
+        [TestMethod]
         public void Dispose()
         {
             var l = new AsyncLock();

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

@@ -5,14 +5,16 @@
 using System;
 using System.Reactive.Concurrency;
 using System.Threading;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class ConcurrencyTest
     {
-        [Fact]
+        [TestMethod]
         public void CurrentScheduler_EnsureTrampoline()
         {
             const int concurrency = 100;
@@ -59,7 +61,7 @@ namespace ReactiveTests.Tests
             Assert.True(passed);
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentScheduler_Schedule()
         {
             const int concurrency = 100;

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

@@ -10,35 +10,37 @@ using System.Reactive.Disposables;
 using System.Diagnostics;
 using System.Threading;
 using System.Windows.Forms;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Microsoft.Reactive.Testing;
 
+using Assert = Xunit.Assert;
+
 namespace ReactiveTests.Tests
 {
-    
+    [TestClass]
     public class ControlSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void Ctor_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ControlScheduler(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Control()
         {
             var lbl = new Label();
             Assert.Same(lbl, new ControlScheduler(lbl).Control);
         }
 
-        [Fact]
+        [TestMethod]
         public void Now()
         {
             var res = new ControlScheduler(new Label()).Now - DateTime.Now;
             Assert.True(res.Seconds < 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void Schedule_ArgumentChecking()
         {
             var s = new ControlScheduler(new Label());
@@ -47,7 +49,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Schedule()
         {
             using (WinFormsTestUtils.RunTest(out var lbl))
@@ -65,7 +67,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleError()
         {
             using (WinFormsTestUtils.RunTest(out var lbl))
@@ -90,13 +92,13 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative()
         {
             ScheduleRelative_(TimeSpan.FromSeconds(0.1));
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative_Zero()
         {
             ScheduleRelative_(TimeSpan.Zero);
@@ -129,7 +131,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative_Nested()
         {
             using (WinFormsTestUtils.RunTest(out var lbl))
@@ -160,7 +162,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative_Cancel()
         {
             using (WinFormsTestUtils.RunTest(out var lbl))
@@ -198,7 +200,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulePeriodic_ArgumentChecking()
         {
             var s = new ControlScheduler(new Label());
@@ -207,7 +209,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.SchedulePeriodic(42, TimeSpan.FromMilliseconds(1).Subtract(TimeSpan.FromTicks(1)), x => x));
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulePeriodic()
         {
             using (WinFormsTestUtils.RunTest(out var lbl))
@@ -249,7 +251,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulePeriodic_Nested()
         {
             using (WinFormsTestUtils.RunTest(out var lbl))
@@ -292,4 +294,4 @@ namespace ReactiveTests.Tests
         }
     }
 }
-#endif
+#endif

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

@@ -7,14 +7,16 @@ using System.Diagnostics;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class CurrentThreadSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.CurrentThread.Schedule(42, default));
@@ -22,7 +24,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.CurrentThread.Schedule(42, default(DateTimeOffset), default));
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_Now()
         {
             var res = Scheduler.CurrentThread.Now - DateTime.Now;
@@ -30,7 +32,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -40,7 +42,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ScheduleActionError()
         {
             var ex = new Exception();
@@ -56,7 +58,7 @@ namespace ReactiveTests.Tests
             }
         }
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ScheduleActionNested()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -69,7 +71,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran);
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ScheduleActionNested_TimeSpan()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -82,7 +84,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran);
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -91,7 +93,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran, "ran");
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_ScheduleActionDueNested()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -109,7 +111,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran, "ran");
         }
 #endif
-        [Fact]
+        [TestMethod]
         public void CurrentThread_EnsureTrampoline()
         {
             var ran1 = false;
@@ -123,7 +125,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran2);
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_EnsureTrampoline_Nested()
         {
             var ran1 = false;
@@ -137,7 +139,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran2);
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_EnsureTrampolineAndCancel()
         {
             var ran1 = false;
@@ -155,7 +157,7 @@ namespace ReactiveTests.Tests
             Assert.False(ran2);
         }
 
-        [Fact]
+        [TestMethod]
         public void CurrentThread_EnsureTrampolineAndCancelTimed()
         {
             var ran1 = false;

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

@@ -6,14 +6,16 @@ using System;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class DefaultSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void Schedule_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => DefaultScheduler.Instance.Schedule(42, default));
@@ -23,14 +25,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DefaultScheduler.Instance.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [Fact]
+        [TestMethod]
         public void Get_Now()
         {
             var res = DefaultScheduler.Instance.Now - DateTime.Now;
             Assert.True(res.Seconds < 1);
         }
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -40,7 +42,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -50,7 +52,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleActionCancel()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -62,7 +64,7 @@ namespace ReactiveTests.Tests
             Assert.False(set);
         }
 
-        [Fact]
+        [TestMethod]
         public void Periodic_NonReentrant()
         {
             var n = 0;
@@ -94,8 +96,8 @@ namespace ReactiveTests.Tests
         }
 #endif
 #if DESKTOPCLR
-        [Trait("SkipCI", "true")]
-        [Fact]
+        [TestCategory("SkipCI")]
+        [TestMethod]
         public void No_ThreadPool_Starvation_Dispose()
         {
             ThreadPool.GetAvailableThreads(out var bwt, out var bio);

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

@@ -10,20 +10,22 @@ using System.Reactive.Disposables;
 using System.Threading;
 using System.Windows.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-    
+    [TestClass]
     public class DispatcherSchedulerTest : TestBase
     {
-        [Fact]
+        [TestMethod]
         public void Ctor_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new DispatcherScheduler(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Current()
         {
             using (DispatcherHelpers.RunTest(out var d))
@@ -40,7 +42,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Current_None()
         {
             var e = default(Exception);
@@ -63,7 +65,7 @@ namespace ReactiveTests.Tests
             Assert.True(e != null && e is InvalidOperationException);
         }
 
-        [Fact]
+        [TestMethod]
         public void Dispatcher()
         {
             using (DispatcherHelpers.RunTest(out var disp))
@@ -72,7 +74,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Now()
         {
             using (DispatcherHelpers.RunTest(out var disp))
@@ -82,7 +84,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Schedule_ArgumentChecking()
         {
             using (DispatcherHelpers.RunTest(out var disp))
@@ -94,7 +96,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         [Asynchronous]
         public void Schedule()
         {
@@ -113,7 +115,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleError()
         {
             using (DispatcherHelpers.RunTest(out var disp))
@@ -138,13 +140,13 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative()
         {
             ScheduleRelative_(TimeSpan.FromSeconds(0.2));
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative_Zero()
         {
             ScheduleRelative_(TimeSpan.Zero);
@@ -175,7 +177,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleRelative_Cancel()
         {
             using (DispatcherHelpers.RunTest(out var disp))
@@ -212,7 +214,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulePeriodic_ArgumentChecking()
         {
             using (DispatcherHelpers.RunTest(out var disp))
@@ -224,7 +226,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulePeriodic()
         {
             using (DispatcherHelpers.RunTest(out var disp))

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

@@ -10,19 +10,21 @@ using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 #if STRESS
 using ReactiveTests.Stress.Schedulers;
 #endif
 
+using Assert = Xunit.Assert;
+
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class EventLoopSchedulerTest
     {
         private static readonly TimeSpan MaxWaitTime = TimeSpan.FromSeconds(10);
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ArgumentChecking()
         {
             using var el = new EventLoopScheduler();
@@ -37,7 +39,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => el.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_Now()
         {
             using var el = new EventLoopScheduler();
@@ -46,7 +48,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.Seconds < 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_DisposeWithInFlightActions()
         {
             using (var scheduler = new EventLoopScheduler())
@@ -59,7 +61,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleAction()
         {
             var ran = false;
@@ -75,7 +77,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void EventLoop_DifferentThread()
         {
             var id = default(int);
@@ -91,7 +93,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleOrderedActions()
         {
             var results = new List<int>();
@@ -107,7 +109,7 @@ namespace ReactiveTests.Tests
             results.AssertEqual(0, 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_SchedulerDisposed()
         {
             var d = 0;
@@ -156,7 +158,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, d);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleTimeOrderedActions()
         {
             var results = new List<int>();
@@ -173,7 +175,7 @@ namespace ReactiveTests.Tests
             results.AssertEqual(1, 0);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleOrderedAndTimedActions()
         {
             var results = new List<int>();
@@ -190,7 +192,7 @@ namespace ReactiveTests.Tests
             results.AssertEqual(1, 0);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleTimeOrderedInFlightActions()
         {
             var results = new List<int>();
@@ -212,7 +214,7 @@ namespace ReactiveTests.Tests
             results.AssertEqual(0, 1, 2);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleTimeAndOrderedInFlightActions()
         {
             var results = new List<int>();
@@ -235,7 +237,7 @@ namespace ReactiveTests.Tests
             results.AssertEqual(0, 4, 1, 2);
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_ScheduleActionNested()
         {
             var ran = false;
@@ -250,7 +252,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran);
         }
 
-        [Fact(Skip = "")]
+        [TestMethod]
         public void EventLoop_ScheduleActionDue()
         {
             var ran = false;
@@ -269,7 +271,7 @@ namespace ReactiveTests.Tests
             Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 
-        [Fact(Skip = "")]
+        [TestMethod]
         public void EventLoop_ScheduleActionDueNested()
         {
             var ran = false;
@@ -296,7 +298,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Stopwatch()
         {
             using var el = new EventLoopScheduler();
@@ -304,7 +306,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_Immediate()
         {
             var M = 1000;
@@ -335,7 +337,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_TimeCollisions()
         {
             var M = 1000;
@@ -366,7 +368,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_Spread()
         {
             var M = 1000;
@@ -397,7 +399,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void EventLoop_Periodic()
         {
             var n = 0;
@@ -424,7 +426,7 @@ namespace ReactiveTests.Tests
         }
 
 #if STRESS
-        [Fact]
+        [TestMethod]
         public void EventLoop_Stress()
         {
             EventLoop.NoSemaphoreFullException();
@@ -432,7 +434,7 @@ namespace ReactiveTests.Tests
 #endif
 
 #if DESKTOPCLR
-        [Fact]
+        [TestMethod]
         public void EventLoop_CorrectWorkStealing()
         {
             const int workItemCount = 100;

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

@@ -8,11 +8,13 @@ using System.Linq;
 using System.Reactive;
 using System.Reactive.Concurrency;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class HistoricalSchedulerTest
     {
         public DateTimeOffset Time(int i)
@@ -20,7 +22,7 @@ namespace ReactiveTests.Tests
             return new DateTimeOffset(1979, 10, 31, 4, 30, 15, TimeSpan.Zero).AddDays(i);
         }
 
-        [Fact]
+        [TestMethod]
         public void Ctor()
         {
             var s = new HistoricalScheduler();
@@ -30,7 +32,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(false, s.IsEnabled);
         }
 
-        [Fact]
+        [TestMethod]
         public void Start_Stop()
         {
             var s = new HistoricalScheduler();
@@ -75,7 +77,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Order()
         {
             var s = new HistoricalScheduler();
@@ -99,7 +101,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Cancellation()
         {
             var s = new HistoricalScheduler();
@@ -121,7 +123,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AdvanceTo_ArgumentChecking()
         {
             var now = DateTimeOffset.Now;
@@ -131,7 +133,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.AdvanceTo(now.Subtract(TimeSpan.FromSeconds(1))));
         }
 
-        [Fact]
+        [TestMethod]
         public void AdvanceTo()
         {
             var s = new HistoricalScheduler();
@@ -210,7 +212,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AdvanceBy_ArgumentChecking()
         {
             var s = new HistoricalScheduler();
@@ -218,7 +220,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.AdvanceBy(TimeSpan.FromSeconds(-1)));
         }
 
-        [Fact]
+        [TestMethod]
         public void AdvanceBy()
         {
             var s = new HistoricalScheduler();
@@ -297,7 +299,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void IsEnabled()
         {
             var s = new HistoricalScheduler();
@@ -318,7 +320,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(false, s.IsEnabled);
         }
 
-        [Fact]
+        [TestMethod]
         public void No_Nested_AdvanceBy()
         {
             var s = new HistoricalScheduler();
@@ -328,7 +330,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => s.Start());
         }
 
-        [Fact]
+        [TestMethod]
         public void No_Nested_AdvanceTo()
         {
             var s = new HistoricalScheduler();
@@ -338,7 +340,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => s.Start());
         }
 
-        [Fact]
+        [TestMethod]
         public void Sleep_ArgumentChecking()
         {
             var s = new HistoricalScheduler(DateTimeOffset.Now);
@@ -346,7 +348,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.Sleep(TimeSpan.FromSeconds(-1)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Sleep1()
         {
             var now = new DateTimeOffset(1983, 2, 11, 12, 0, 0, TimeSpan.Zero);
@@ -358,7 +360,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(now + TimeSpan.FromDays(1), s.Clock);
         }
 
-        [Fact]
+        [TestMethod]
         public void Sleep2()
         {
             var s = new HistoricalScheduler();
@@ -378,13 +380,13 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, n);
         }
 
-        [Fact]
+        [TestMethod]
         public void WithComparer_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new HistoricalScheduler(DateTimeOffset.Now, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void WithComparer()
         {
             var now = DateTimeOffset.Now;

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

@@ -8,21 +8,23 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class ImmediateSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void Immediate_Now()
         {
             var res = Scheduler.Immediate.Now - DateTime.Now;
             Assert.True(res.Seconds < 1);
         }
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Immediate_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -32,7 +34,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Immediate_ScheduleActionError()
         {
             var ex = new Exception();
@@ -48,7 +50,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule(42, default));
@@ -56,7 +58,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Immediate.Schedule(42, TimeSpan.Zero, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_Simple1()
         {
             var _x = 0;
@@ -64,7 +66,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(42, _x);
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_Simple2()
         {
             var _x = 0;
@@ -72,7 +74,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(42, _x);
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_Simple3()
         {
             var _x = 0;
@@ -80,7 +82,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(42, _x);
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_Recursive1()
         {
             var _x = 0;
@@ -90,7 +92,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(43, _y);
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_Recursive2()
         {
             var _x = 0;
@@ -100,7 +102,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(43, _y);
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_Recursive3()
         {
             var _x = 0;
@@ -110,7 +112,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(43, _y);
         }
 
-        [Fact]
+        [TestMethod]
         public void Immediate_ArgumentChecking_More()
         {
             Scheduler.Immediate.Schedule(42, (self, state) =>
@@ -145,7 +147,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Immediate_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;

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

@@ -7,14 +7,17 @@ using System.Diagnostics;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
 #if !NO_THREAD
+    [TestClass]
     public class NewThreadSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void NewThread_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new NewThreadScheduler(null));
@@ -26,14 +29,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => NewThreadScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [Fact]
+        [TestMethod]
         public void NewThread_Now()
         {
             var res = NewThreadScheduler.Default.Now - DateTime.Now;
             Assert.True(res.Seconds < 1);
         }
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void NewThread_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -43,7 +46,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void NewThread_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -55,14 +58,14 @@ namespace ReactiveTests.Tests
 #endif
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Stopwatch()
         {
             StopwatchTest.Run(NewThreadScheduler.Default);
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void NewThread_Periodic()
         {
             var n = 0;
@@ -85,7 +88,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void NewThread_Periodic_NonReentrant()
         {
             var n = 0;

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

@@ -7,14 +7,16 @@ using System.Collections.Generic;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests
 {
-
+    [TestClass]
     public class ScheduledItemTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledItem<DateTimeOffset, int>(default, 42, (x, y) => Disposable.Empty, DateTimeOffset.Now));
@@ -25,7 +27,7 @@ namespace ReactiveTests
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledItem<DateTimeOffset, int>(Scheduler.Default, 42, (x, y) => Disposable.Empty, DateTimeOffset.Now, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Inequalities()
         {
             var si1 = new SI(42);
@@ -79,7 +81,7 @@ namespace ReactiveTests
             Assert.False(si5 <= si4);
         }
 
-        [Fact]
+        [TestMethod]
         public void Equalities()
         {
             var si1 = new SI2(42, 123);

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

@@ -11,7 +11,7 @@ using System.Reactive.Linq;
 using System.Reactive.PlatformServices;
 using System.Runtime.CompilerServices;
 using System.Threading;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Microsoft.Reactive.Testing;
 
 #if HAS_WINFORMS
@@ -20,15 +20,16 @@ using System.Windows.Forms;
 
 using System.Threading.Tasks;
 
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class SchedulerTest : ReactiveTest
     {
         #region IScheduler
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ArgumentChecks()
         {
             var ms = new MyScheduler();
@@ -50,7 +51,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Schedule(ms, 1, TimeSpan.Zero, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Schedulers_ArgumentChecks()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.CurrentThread.Schedule(default(Action)));
@@ -109,7 +110,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => new SynchronizationContextScheduler(ctx).Schedule(DateTimeOffset.MaxValue, default(Action)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ScheduleNonRecursive()
         {
             var ms = new MyScheduler();
@@ -118,7 +119,7 @@ namespace ReactiveTests.Tests
             Assert.True(res);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ScheduleRecursive()
         {
             var ms = new MyScheduler();
@@ -127,7 +128,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(10, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_Schedule_With_State()
         {
             var ms = new MyScheduler();
@@ -136,7 +137,7 @@ namespace ReactiveTests.Tests
             Assert.True(res);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ScheduleWithTimeNonRecursive()
         {
             var now = DateTimeOffset.Now;
@@ -147,7 +148,7 @@ namespace ReactiveTests.Tests
             Assert.True(ms.WaitCycles == 0);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ScheduleWithTimeRecursive()
         {
             var now = DateTimeOffset.Now;
@@ -158,7 +159,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(10, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ScheduleWithTimeSpanNonRecursive()
         {
             var now = DateTimeOffset.Now;
@@ -169,7 +170,7 @@ namespace ReactiveTests.Tests
             Assert.True(ms.WaitCycles == 0);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_ScheduleWithTimeSpanRecursive()
         {
             var now = DateTimeOffset.Now;
@@ -180,7 +181,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(10, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_StateThreading()
         {
             var lst = new List<int>();
@@ -196,7 +197,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_Builtins()
         {
             // Default
@@ -243,7 +244,7 @@ namespace ReactiveTests.Tests
 #if !NO_PERF
 
 #if !WINDOWS && !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Scheduler_LongRunning_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.ScheduleLongRunning(null, c => { }));
@@ -257,7 +258,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.ScheduleLongRunning(ThreadPoolScheduler.Instance, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_Periodic_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.SchedulePeriodic(null, TimeSpan.FromSeconds(1), () => { }));
@@ -274,13 +275,13 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_Stopwatch_Emulation()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.StartStopwatch(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_LongRunning1()
         {
             var s = TaskPoolScheduler.Default;
@@ -304,7 +305,7 @@ namespace ReactiveTests.Tests
             e.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_LongRunning2()
         {
             var s = TaskPoolScheduler.Default;
@@ -336,7 +337,7 @@ namespace ReactiveTests.Tests
 #if !NO_PERF
 
 #if !WINDOWS && !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Scheduler_Periodic1()
         {
             var n = 0;
@@ -354,7 +355,7 @@ namespace ReactiveTests.Tests
             d.Dispose();
         }
 
-        [Fact]
+        [TestMethod]
         public void Scheduler_Periodic2()
         {
             var n = 0;
@@ -376,7 +377,7 @@ namespace ReactiveTests.Tests
 #endif
 
 #if DESKTOPCLR && NET472
-        [Fact]
+        [TestMethod]
         public void Scheduler_Periodic_HostLifecycleManagement()
         {
             var cur = AppDomain.CurrentDomain.BaseDirectory;
@@ -476,7 +477,7 @@ namespace ReactiveTests.Tests
         #region DisableOptimizations
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void DisableOptimizations_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.DisableOptimizations(default));
@@ -489,7 +490,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.DisableOptimizations(Scheduler.Default).Schedule(42, DateTimeOffset.Now, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void DisableOptimizations1()
         {
             var s = TaskPoolScheduler.Default;
@@ -525,7 +526,7 @@ namespace ReactiveTests.Tests
             e3.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void DisableOptimizations2()
         {
             var s = TaskPoolScheduler.Default;
@@ -567,7 +568,7 @@ namespace ReactiveTests.Tests
             e2.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void DisableOptimizations3()
         {
             var s = TaskPoolScheduler.Default;
@@ -622,7 +623,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void DisableOptimizations_UnknownService()
         {
             var s = new MyScheduler();
@@ -676,7 +677,7 @@ namespace ReactiveTests.Tests
 
         #region Catch
 
-        [Fact]
+        [TestMethod]
         public void Catch_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Catch<Exception>(default, _ => true));
@@ -687,7 +688,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Catch<Exception>(Scheduler.Default, _ => true).Schedule(42, DateTimeOffset.Now, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Builtin_Swallow_Shallow()
         {
             var done = new ManualResetEvent(false);
@@ -702,7 +703,7 @@ namespace ReactiveTests.Tests
             done.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Builtin_Swallow_Recursive()
         {
             var done = new ManualResetEvent(false);
@@ -720,7 +721,7 @@ namespace ReactiveTests.Tests
             done.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_Unhandled()
         {
             var err = default(Exception);
@@ -740,7 +741,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_Rethrow()
         {
             var err = default(Exception);
@@ -754,7 +755,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_LongRunning_Caught()
         {
             var err = default(Exception);
@@ -779,7 +780,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_LongRunning_Rethrow()
         {
             var err = default(Exception);
@@ -803,7 +804,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_Periodic_Regular()
         {
             var scheduler = new MyExceptionScheduler(_ => { })
@@ -830,7 +831,7 @@ namespace ReactiveTests.Tests
             scheduler.PeriodicStopped.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_Periodic_Uncaught1()
         {
             var err = default(Exception);
@@ -854,7 +855,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_Periodic_Uncaught2()
         {
             var err = default(Exception);
@@ -878,7 +879,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Custom_Periodic_Caught()
         {
             var err = default(Exception);
@@ -984,7 +985,7 @@ namespace ReactiveTests.Tests
 
         #region Services
 
-        [Fact]
+        [TestMethod]
         public void InvalidService_Null()
         {
             var s = new MySchedulerWithoutServices();
@@ -999,7 +1000,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void DetectServices_Null_1()
         {
             var s = new MyDumbScheduler1();
@@ -1031,7 +1032,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void DetectServices_Null_2()
         {
             var s = new MyDumbScheduler2(new Dictionary<Type, object>());
@@ -1040,7 +1041,7 @@ namespace ReactiveTests.Tests
             Assert.Null(Scheduler.AsStopwatchProvider(s));
         }
 
-        [Fact]
+        [TestMethod]
         public void DetectServices_Found()
         {
             {
@@ -1143,14 +1144,14 @@ namespace ReactiveTests.Tests
 
         #endregion
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_Yield_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Yield(default));
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Yield(default, CancellationToken.None));
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_Sleep_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Sleep(default, TimeSpan.Zero));
@@ -1160,7 +1161,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.Sleep(default, DateTimeOffset.MinValue, CancellationToken.None));
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_ArgumentChecking()
         {
             var tcs = new TaskCompletionSource<IDisposable>();
@@ -1213,7 +1214,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Scheduler.ScheduleAsync(s, at, d4));
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_Overloads1()
         {
             var tcsI = new TaskCompletionSource<int>();
@@ -1262,7 +1263,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_Overloads2()
         {
             var tcsI = new TaskCompletionSource<int>();
@@ -1311,7 +1312,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_Overloads3()
         {
             var tcsI = new TaskCompletionSource<int>();
@@ -1360,7 +1361,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_NoCancellation1()
         {
             var s = new TestScheduler();
@@ -1394,7 +1395,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_NoCancellation2()
         {
             var s = new TestScheduler();
@@ -1428,7 +1429,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_Awaiters()
         {
             var op = Scheduler.Immediate.Yield();
@@ -1441,7 +1442,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => aw.OnCompleted(() => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_Yield_Cancel1()
         {
             var cts = new CancellationTokenSource();
@@ -1456,7 +1457,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OperationCanceledException>(() => aw.GetResult());
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_Yield_Cancel2()
         {
             var cts = new CancellationTokenSource();
@@ -1479,7 +1480,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_Sleep_Cancel()
         {
             var cts = new CancellationTokenSource();
@@ -1505,7 +1506,7 @@ namespace ReactiveTests.Tests
 
 #if !NO_SYNCCTX
 
-        [Fact]
+        [TestMethod]
         public void SchedulerAsync_ScheduleAsync_SyncCtx()
         {
             var old = SynchronizationContext.Current;

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

@@ -8,14 +8,16 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class SynchronizationContextSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_ArgumentChecking()
         {
             var ms = new MySync();
@@ -28,7 +30,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, TimeSpan.Zero, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_Now()
         {
             var ms = new MySync();
@@ -38,7 +40,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.Seconds < 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_ScheduleAction()
         {
             var ms = new MySync();
@@ -50,7 +52,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran);
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_ScheduleAction_TimeSpan()
         {
             var ms = new MySync();
@@ -63,7 +65,7 @@ namespace ReactiveTests.Tests
             Assert.True(ms.Count == 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_ScheduleAction_DateTimeOffset()
         {
             var ms = new MySync();
@@ -76,7 +78,7 @@ namespace ReactiveTests.Tests
             Assert.True(ms.Count >= 1); // Can be > 1 in case of timer queue retry operations.
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_ScheduleActionError()
         {
             var ms = new MySync();
@@ -97,7 +99,7 @@ namespace ReactiveTests.Tests
             Assert.True(ms.Count == 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_ScheduleActionDue()
         {
             var ms = new MySync();
@@ -144,7 +146,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_StartedCompleted()
         {
             var ms = new MySync();
@@ -158,7 +160,7 @@ namespace ReactiveTests.Tests
             Assert.True(ms.Completed == 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_DontPost_Different()
         {
             var ms = new MySync();
@@ -171,7 +173,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_DontPost_Same()
         {
             var count = 0;
@@ -196,7 +198,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_AlwaysPost_Different()
         {
             var ms = new MySync();
@@ -209,7 +211,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void SynchronizationContext_AlwaysPost_Same()
         {
             var count = 0;

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

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

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

@@ -6,14 +6,16 @@ using System;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class TaskPoolSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void TaskPool_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new TaskPoolScheduler(null));
@@ -24,7 +26,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => TaskPoolScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _));
         }
 
-        [Fact]
+        [TestMethod]
         public void TaskPool_Now()
         {
             var res = TaskPoolScheduler.Default.Now - DateTime.Now;
@@ -32,7 +34,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void TaskPool_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -42,7 +44,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void TaskPool_ScheduleActionDueNow()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -52,7 +54,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void TaskPool_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -62,7 +64,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void TaskPool_ScheduleActionCancel()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -75,7 +77,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void TaskPool_ScheduleLongRunning()
         {
             var n = 0;
@@ -117,14 +119,14 @@ namespace ReactiveTests.Tests
 #endif
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Stopwatch()
         {
             StopwatchTest.Run(TaskPoolScheduler.Default);
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void TaskPool_Periodic()
         {
             var n = 0;
@@ -147,7 +149,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void TaskPool_Periodic_NonReentrant()
         {
             var n = 0;
@@ -179,7 +181,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void TaskPool_Delay_LargerThanIntMaxValue()
         {
             var dueTime = TimeSpan.FromMilliseconds((double)int.MaxValue + 1);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TestSchedulerTest.cs

@@ -10,14 +10,14 @@ using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class TestSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void Test_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new TestScheduler().Start<int>(null));

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

@@ -9,14 +9,16 @@ using System.Linq;
 using System.Reactive.Concurrency;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class ThreadPoolSchedulerTest
     {
-        [Fact]
+        [TestMethod]
         public void Schedule_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, default));
@@ -24,14 +26,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, TimeSpan.Zero, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Get_Now()
         {
             var res = ThreadPoolScheduler.Instance.Now - DateTime.Now;
             Assert.True(res.Seconds < 1);
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -41,7 +43,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ProperRooting_NoGC_SingleShot()
         {
             var cts = new CancellationTokenSource();
@@ -68,7 +70,7 @@ namespace ReactiveTests.Tests
             cts.Cancel();
         }
 
-        [Fact]
+        [TestMethod]
         public void ProperRooting_NoGC_Periodic()
         {
             var cts = new CancellationTokenSource();
@@ -96,7 +98,7 @@ namespace ReactiveTests.Tests
             cts.Cancel();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleActionDueRelative()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -106,7 +108,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleActionDue0()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -116,7 +118,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleActionDueAbsolute()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -126,7 +128,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleActionCancel()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -140,13 +142,15 @@ namespace ReactiveTests.Tests
 
 #if !NO_PERF
 
-        [Fact]
+#if !WINDOWS_UWP
+
+        [TestMethod]
         public void ScheduleLongRunning_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.ScheduleLongRunning(42, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleLongRunning()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -156,7 +160,7 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduleLongRunningCancel()
         {
             var nt = ThreadPoolScheduler.Instance;
@@ -186,7 +190,9 @@ namespace ReactiveTests.Tests
             Assert.True(n >= 10);
         }
 
-        [Fact]
+#endif
+
+        [TestMethod]
         public void Stopwatch()
         {
             var nt = ThreadPoolScheduler.Instance;
@@ -200,25 +206,29 @@ namespace ReactiveTests.Tests
             Assert.True(s1 > s0);
         }
 
-        [Fact]
+        [TestMethod]
         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), _ => _));
         }
 
-        [Fact]
+        [TestMethod]
         public void Periodic_Regular()
         {
             Periodic_Impl(TimeSpan.FromMilliseconds(25));
         }
 
-        [Fact]
+#if !WINDOWS_UWP
+
+        [TestMethod]
         public void Periodic_Zero()
         {
             Periodic_Impl(TimeSpan.Zero);
         }
 
+#endif
+
         private void Periodic_Impl(TimeSpan period)
         {
             var gate = new object();
@@ -270,7 +280,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.Take(10).SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Periodic_NonReentrant()
         {
             var n = 0;
@@ -304,8 +314,8 @@ namespace ReactiveTests.Tests
 #endif
 
 #if DESKTOPCLR
-        [Trait("SkipCI", "true")]
-        [Fact]
+        [TestCategory("SkipCI")]
+        [TestMethod]
         public void No_ThreadPool_Starvation_Dispose()
         {
             ThreadPool.GetAvailableThreads(out var bwt, out var bio);

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

@@ -10,11 +10,13 @@ using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class VirtualSchedulerTest
     {
         private class VirtualSchedulerTestScheduler : VirtualTimeScheduler<string, char>
@@ -44,14 +46,14 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Virtual_Now()
         {
             var res = new VirtualSchedulerTestScheduler().Now - DateTime.Now;
             Assert.True(res.Seconds < 1);
         }
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Virtual_ScheduleAction()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -63,7 +65,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Virtual_ScheduleActionError()
         {
             var ex = new Exception();
@@ -81,14 +83,14 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Virtual_InitialAndComparer_Now()
         {
             var s = new VirtualSchedulerTestScheduler("Bar", Comparer<string>.Default);
             Assert.Equal(3, s.Now.Ticks);
         }
 
-        [Fact]
+        [TestMethod]
         public void Virtual_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new VirtualSchedulerTestScheduler("", null));
@@ -104,7 +106,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => VirtualTimeSchedulerExtensions.ScheduleRelative(new VirtualSchedulerTestScheduler(), 'a', default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Historical_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new HistoricalScheduler(DateTime.Now, default));
@@ -113,7 +115,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Virtual_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
@@ -125,8 +127,8 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
-        [Trait("SkipCI", "true")]
+        [TestMethod]
+        [TestCategory("SkipCI")]
         public void Virtual_ThreadSafety()
         {
             for (var i = 0; i < 10; i++)

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

@@ -8,14 +8,16 @@ using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public partial class ConnectableObservableTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_Creation()
         {
             var y = 0;
@@ -30,7 +32,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, y);
         }
 
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_Connected()
         {
             var scheduler = new TestScheduler();
@@ -59,7 +61,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_NotConnected()
         {
             var scheduler = new TestScheduler();
@@ -82,7 +84,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_Disconnected()
         {
             var scheduler = new TestScheduler();
@@ -107,7 +109,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_DisconnectFuture()
         {
             var scheduler = new TestScheduler();
@@ -134,13 +136,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.Publish().Subscribe(default));
         }
 
-        [Fact]
+        [TestMethod]
         public void ConnectableObservable_MultipleNonOverlappedConnections()
         {
             var scheduler = new TestScheduler();

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

@@ -8,11 +8,13 @@ using System.Reactive.Concurrency;
 using System.Reactive.PlatformServices;
 using System.Runtime.CompilerServices;
 using System.Threading;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     [Serializable]
     public class DefaultConcurrencyAbstractionLayerTest
     {
@@ -31,7 +33,7 @@ namespace ReactiveTests.Tests
             _domain.DoCallBack(a);
         }
 
-        [Fact]
+        [TestMethod]
         public void Sleep()
         {
             var ran = new MarshalByRefCell<bool>();
@@ -49,7 +51,7 @@ namespace ReactiveTests.Tests
             Assert.True(ran.Value);
         }
 
-        [Fact]
+        [TestMethod]
         public void QueueUserWorkItem()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -67,7 +69,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void StartTimer()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -85,7 +87,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void StartTimer_Cancel()
         {
             Run(StartTimer_Cancel_Callback);
@@ -99,7 +101,7 @@ namespace ReactiveTests.Tests
             }).Dispose();
         }
 
-        [Fact]
+        [TestMethod]
         public void StartPeriodicTimer()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -123,7 +125,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void StartPeriodicTimer_Cancel()
         {
             Run(StartPeriodicTimer_Cancel_Callback);
@@ -137,7 +139,7 @@ namespace ReactiveTests.Tests
             }).Dispose();
         }
 
-        [Fact]
+        [TestMethod]
         public void StartPeriodicTimer_Fast()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -161,7 +163,7 @@ namespace ReactiveTests.Tests
             e.Value.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void StartPeriodicTimer_Fast_Cancel()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -208,7 +210,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(newValue, value);
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateThread()
         {
             var e = new MarshalByRefCell<ManualResetEvent> { Value = new ManualResetEvent(false) };
@@ -283,7 +285,7 @@ namespace ReactiveTests.Tests
             Assert.True(string.IsNullOrEmpty(r.Value));
         }
 
-        [Fact]
+        [TestMethod]
         public void Cant_Locate_Scheduler()
         {
 
@@ -314,7 +316,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Stopwatch()
         {
             var e = new MarshalByRefCell<bool>();
@@ -337,7 +339,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void EnsureLoaded()
         {
             Assert.True(EnlightenmentProvider.EnsureLoaded());

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

@@ -10,27 +10,29 @@ using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
-
+    [TestClass]
     public class DisposableTests
     {
-        [Fact]
+        [TestMethod]
         public void AnonymousDisposable_Create()
         {
             var d = Disposable.Create(() => { });
             Assert.NotNull(d);
         }
 
-        [Fact]
+        [TestMethod]
         public void AnonymousDisposable_CreateNull()
         {
             Assert.Throws(typeof(ArgumentNullException), () => Disposable.Create(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void AnonymousDisposable_Dispose()
         {
             var disposed = false;
@@ -44,7 +46,7 @@ namespace ReactiveTests.Tests
             Assert.True(c.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void EmptyDisposable()
         {
             var d = Disposable.Empty;
@@ -52,7 +54,7 @@ namespace ReactiveTests.Tests
             d.Dispose();
         }
 
-        [Fact]
+        [TestMethod]
         public void BooleanDisposable()
         {
             var d = new BooleanDisposable();
@@ -63,7 +65,7 @@ namespace ReactiveTests.Tests
             Assert.True(d.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void SingleAssignmentDisposable_SetNull()
         {
             var d = new SingleAssignmentDisposable
@@ -72,7 +74,7 @@ namespace ReactiveTests.Tests
             };
         }
 
-        [Fact]
+        [TestMethod]
         public void SingleAssignmentDisposable_DisposeAfterSet()
         {
             var disposed = false;
@@ -92,7 +94,7 @@ namespace ReactiveTests.Tests
             Assert.True(d.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void SingleAssignmentDisposable_DisposeBeforeSet()
         {
             var disposed = false;
@@ -114,7 +116,7 @@ namespace ReactiveTests.Tests
             Assert.True(disposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void SingleAssignmentDisposable_SetMultipleTimes()
         {
             var d = new SingleAssignmentDisposable
@@ -125,7 +127,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => { d.Disposable = Disposable.Empty; });
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable(default(IDisposable[])));
@@ -133,7 +135,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new CompositeDisposable(-1));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_Contains()
         {
             var d1 = Disposable.Create(() => { });
@@ -147,31 +149,31 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => g.Contains(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_IsReadOnly()
         {
             Assert.False(new CompositeDisposable().IsReadOnly);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_CopyTo_Null()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable().CopyTo(null, 0));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_CopyTo_Negative()
         {
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new CompositeDisposable().CopyTo(new IDisposable[2], -1));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_CopyTo_BeyondEnd()
         {
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => new CompositeDisposable().CopyTo(new IDisposable[2], 2));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_CopyTo()
         {
             var d1 = Disposable.Create(() => { });
@@ -184,7 +186,7 @@ namespace ReactiveTests.Tests
             Assert.Same(d2, d[2]);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_ToArray()
         {
             var d1 = Disposable.Create(() => { });
@@ -195,7 +197,7 @@ namespace ReactiveTests.Tests
             Assert.True(g.ToArray().SequenceEqual(new[] { d1, d2 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_GetEnumerator()
         {
             var d1 = Disposable.Create(() => { });
@@ -210,7 +212,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { d1, d2 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_GetEnumeratorNonGeneric()
         {
             var d1 = Disposable.Create(() => { });
@@ -225,7 +227,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { d1, d2 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_CollectionInitializer()
         {
             var d1 = Disposable.Create(() => { });
@@ -236,27 +238,27 @@ namespace ReactiveTests.Tests
             Assert.True(g.Contains(d2));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_AddNull_via_params_ctor()
         {
             IDisposable d1 = null;
             ReactiveAssert.Throws<ArgumentException>(() => new CompositeDisposable(d1));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_AddNull_via_IEnum_ctor()
         {
             IEnumerable<IDisposable> values = new IDisposable[] { null };
             ReactiveAssert.Throws<ArgumentException>(() => new CompositeDisposable(values));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_AddNull()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable().Add(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_Add()
         {
             var d1 = Disposable.Create(() => { });
@@ -269,7 +271,7 @@ namespace ReactiveTests.Tests
             Assert.True(g.Contains(d2));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_AddAfterDispose()
         {
             var disp1 = false;
@@ -291,7 +293,7 @@ namespace ReactiveTests.Tests
             Assert.True(g.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_Remove()
         {
             var disp1 = false;
@@ -322,7 +324,7 @@ namespace ReactiveTests.Tests
             Assert.False(disp3);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_Clear()
         {
             var disp1 = false;
@@ -345,7 +347,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, g.Count);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_RemoveOptimizationBehavior()
         {
             var g = new CompositeDisposable();
@@ -393,13 +395,13 @@ namespace ReactiveTests.Tests
             Assert.True(z.SequenceEqual(Enumerable.Range(0, N).Where(i => !(i % 2 == 0 || i % 3 == 0 || i % 5 == 0))));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_RemoveNull()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new CompositeDisposable().Remove(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_Empty_GetEnumerator()
         {
             var composite = new CompositeDisposable();
@@ -407,7 +409,7 @@ namespace ReactiveTests.Tests
             Assert.False(composite.GetEnumerator().MoveNext());
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_NonCollection_Enumerable_Init()
         {
             var d = new BooleanDisposable();
@@ -424,7 +426,7 @@ namespace ReactiveTests.Tests
             yield return d;
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_Disposed_Is_NoOp()
         {
             var d = new BooleanDisposable();
@@ -444,7 +446,7 @@ namespace ReactiveTests.Tests
             Assert.Null(array[0]);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_CopyTo_Index_Out_Of_Range()
         {
             var d1 = new BooleanDisposable();
@@ -465,7 +467,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_GetEnumerator_Reset()
         {
             var d = new BooleanDisposable();
@@ -484,7 +486,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(d, enumerator.Current);
         }
 
-        [Fact]
+        [TestMethod]
         public void CompositeDisposable_GetEnumerator_Disposed_Entries()
         {
             var d1 = new BooleanDisposable();
@@ -506,13 +508,13 @@ namespace ReactiveTests.Tests
             Assert.False(enumerator.MoveNext());
         }
 
-        [Fact]
+        [TestMethod]
         public void CancellationDisposable_Ctor_Null()
         {
             Assert.Throws<ArgumentNullException>(() => new CancellationDisposable(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void CancellationDisposable_DefaultCtor()
         {
             var c = new CancellationDisposable();
@@ -524,7 +526,7 @@ namespace ReactiveTests.Tests
             Assert.True(c.Token.IsCancellationRequested);
         }
 
-        [Fact]
+        [TestMethod]
         public void CancellationDisposable_TokenCtor()
         {
             var t = new CancellationTokenSource();
@@ -537,19 +539,19 @@ namespace ReactiveTests.Tests
             Assert.True(c.Token.IsCancellationRequested);
         }
 
-        [Fact]
+        [TestMethod]
         public void ContextDisposable_CreateNullContext()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ContextDisposable(null, Disposable.Empty));
         }
 
-        [Fact]
+        [TestMethod]
         public void ContextDisposable_CreateNullDisposable()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ContextDisposable(new SynchronizationContext(), null));
         }
 
-        [Fact]
+        [TestMethod]
         public void ContextDisposable()
         {
             var disp = false;
@@ -575,14 +577,14 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void SerialDisposable_Ctor_Prop()
         {
             var m = new SerialDisposable();
             Assert.Null(m.Disposable);
         }
 
-        [Fact]
+        [TestMethod]
         public void SerialDisposable_ReplaceBeforeDispose()
         {
             var disp1 = false;
@@ -601,7 +603,7 @@ namespace ReactiveTests.Tests
             Assert.False(disp2);
         }
 
-        [Fact]
+        [TestMethod]
         public void SerialDisposable_ReplaceAfterDispose()
         {
             var disp1 = false;
@@ -622,7 +624,7 @@ namespace ReactiveTests.Tests
             Assert.True(disp2);
         }
 
-        [Fact]
+        [TestMethod]
         public void SerialDisposable_Dispose()
         {
             var disp = false;
@@ -639,13 +641,13 @@ namespace ReactiveTests.Tests
             //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal.
         }
 
-        [Fact]
+        [TestMethod]
         public void RefCountDisposable_Ctor_Null()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new RefCountDisposable(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void RefCountDisposable_SingleReference()
         {
             var d = new BooleanDisposable();
@@ -657,7 +659,7 @@ namespace ReactiveTests.Tests
             Assert.True(d.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void RefCountDisposable_RefCounting()
         {
             var d = new BooleanDisposable();
@@ -682,7 +684,7 @@ namespace ReactiveTests.Tests
             d3.Dispose();
         }
 
-        [Fact]
+        [TestMethod]
         public void RefCountDisposable_PrimaryDisposesFirst()
         {
             var d = new BooleanDisposable();
@@ -703,7 +705,7 @@ namespace ReactiveTests.Tests
             Assert.True(d.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void RefCountDisposable_Throw_If_Disposed()
         {
             var d = new BooleanDisposable();
@@ -715,14 +717,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ObjectDisposedException>(() => { r.GetDisposable(); });
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduledDisposable_Null()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledDisposable(null, Disposable.Empty));
             ReactiveAssert.Throws<ArgumentNullException>(() => new ScheduledDisposable(Scheduler.Immediate, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void ScheduledDisposable()
         {
             var d = new BooleanDisposable();
@@ -743,7 +745,7 @@ namespace ReactiveTests.Tests
             s.Disposable.Dispose();            // This should be a nop.
         }
 
-        [Fact]
+        [TestMethod]
         public void MultipleAssignmentDisposable()
         {
             var m = new MultipleAssignmentDisposable();
@@ -776,7 +778,7 @@ namespace ReactiveTests.Tests
             Assert.True(m.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void StableCompositeDisposable_ArgumentChecking()
         {
             var d = Disposable.Empty;
@@ -792,7 +794,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentException>(() => StableCompositeDisposable.Create(d, d, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void StableCompositeDisposable_Binary()
         {
             var disp1 = false;
@@ -820,7 +822,7 @@ namespace ReactiveTests.Tests
             Assert.True(d.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void StableCompositeDisposable_Nary1()
         {
             var disp1 = false;
@@ -854,7 +856,7 @@ namespace ReactiveTests.Tests
             Assert.True(d.IsDisposed);
         }
 
-        [Fact]
+        [TestMethod]
         public void StableCompositeDisposable_Nary2()
         {
             var disp1 = false;

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

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

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

@@ -5,16 +5,18 @@
 #if SIGNED
 using System.Linq;
 using System.Reactive;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 #endif
 
+using Assert = Xunit.Assert;
+
 namespace ReactiveTests.Tests
 {
 #if SIGNED
-
+    [TestClass]
     public class ImmutableListTest
     {
-        [Fact]
+        [TestMethod]
         public void ImmutableList_Basics()
         {
             var list = ImmutableList<int>.Empty;
@@ -52,7 +54,7 @@ namespace ReactiveTests.Tests
             Assert.True(list.Data.SequenceEqual(new int[] { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void ImmutableList_Nulls()
         {
             var list = ImmutableList<string>.Empty;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/ExceptionHelperTest.cs

@@ -4,15 +4,18 @@
 
 using System;
 using System.Reactive;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ExceptionHelperTest
     {
         private Exception _errors;
 
-        [Fact]
+        [TestMethod]
         public void ExceptionHelper_TrySetException_Empty()
         {
             var ex = new InvalidOperationException();
@@ -22,7 +25,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(ex, _errors);
         }
 
-        [Fact]
+        [TestMethod]
         public void ExceptionHelper_TrySetException_Not_Empty()
         {
             var ex1 = new InvalidOperationException();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/HalfSerializerTest.cs

@@ -5,17 +5,20 @@
 using System;
 using System.Collections.Generic;
 using System.Reactive;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class HalfSerializerTest
     {
         private int _wip;
         private Exception _error;
         private Consumer _consumer = new Consumer();
 
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnNext()
         {
             HalfSerializer.ForwardOnNext(_consumer, 1, ref _wip, ref _error);
@@ -29,7 +32,7 @@ namespace ReactiveTests.Tests
             Assert.Null(_consumer.Exc);
         }
 
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnError()
         {
             var ex = new InvalidOperationException();
@@ -46,7 +49,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(ex, _consumer.Exc);
         }
 
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnError_Ignore_Further_Events()
         {
             var ex = new InvalidOperationException();
@@ -66,7 +69,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(ex, _consumer.Exc);
         }
 
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnCompleted()
         {
             HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error);
@@ -81,7 +84,7 @@ namespace ReactiveTests.Tests
             Assert.Null(_consumer.Exc);
         }
 
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnCompleted_Ignore_Further_Events()
         {
             HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error);
@@ -100,7 +103,7 @@ namespace ReactiveTests.Tests
         }
 
         // Practically simulates concurrent invocation of the HalfSerializer methods
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnNext_Reentrant_Error()
         {
             var c = new ReentrantConsumer(this, true);
@@ -117,7 +120,7 @@ namespace ReactiveTests.Tests
         }
 
         // Practically simulates concurrent invocation of the HalfSerializer methods
-        [Fact]
+        [TestMethod]
         public void HalfSerializer_OnNext_Reentrant_OnCompleted()
         {
             var c = new ReentrantConsumer(this, false);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/PriorityQueueTest.cs

@@ -1,15 +1,18 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information.
 
 using System.Reactive;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class PriorityQueueTest
     {
-        [Fact]
+        [TestMethod]
         public void Enqueue_dequeue()
         {
             var q = new PriorityQueue<int>();
@@ -28,7 +31,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Enqueue_all_dequeue_all()
         {
             var q = new PriorityQueue<int>();
@@ -51,7 +54,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(0, q.Count);
         }
 
-        [Fact]
+        [TestMethod]
         public void Reverse_Enqueue_all_dequeue_all()
         {
             var q = new PriorityQueue<int>();
@@ -74,7 +77,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(0, q.Count);
         }
 
-        [Fact]
+        [TestMethod]
         public void Remove_from_middle()
         {
             var q = new PriorityQueue<int>();
@@ -97,7 +100,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Repro_329()
         {
             var queue = new PriorityQueue<int>();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/LicenseHeaderTest.cs

@@ -4,7 +4,9 @@
 
 using System.IO;
 using System.Text;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace Tests.System.Reactive.Tests
 {
@@ -12,6 +14,7 @@ namespace Tests.System.Reactive.Tests
     /// Verify that main classes and unit tests have a license header
     /// in the source files.
     /// </summary>
+    [TestClass]
     public class LicenseHeaderTest
     {
         private static readonly bool FixHeaders = true;
@@ -22,7 +25,7 @@ namespace Tests.System.Reactive.Tests
             ""
         };
 
-        [Fact]
+        [TestMethod]
         public void ScanFiles()
         {
             var dir = Directory.GetCurrentDirectory();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AggregateTest.cs

@@ -7,13 +7,14 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AggregateTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Aggregate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int>(default, 1, (x, y) => x + y));
@@ -27,7 +28,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Aggregate<int, int, int>(DummyObservable<int>.Instance, 1, (x, y) => x + y, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeed_Empty()
         {
             var scheduler = new TestScheduler();
@@ -51,7 +52,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeed_Return()
         {
             var scheduler = new TestScheduler();
@@ -76,7 +77,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeed_Throw()
         {
             var ex = new Exception();
@@ -101,7 +102,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeed_Never()
         {
             var ex = new Exception();
@@ -124,7 +125,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeed_Range()
         {
             var ex = new Exception();
@@ -155,7 +156,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeed_AccumulatorThrows()
         {
             var ex = new Exception();
@@ -185,7 +186,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_Empty()
         {
             var scheduler = new TestScheduler();
@@ -209,7 +210,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_Return()
         {
             var scheduler = new TestScheduler();
@@ -234,7 +235,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_Throw()
         {
             var ex = new Exception();
@@ -259,7 +260,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_Never()
         {
             var ex = new Exception();
@@ -282,7 +283,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_Range()
         {
             var ex = new Exception();
@@ -313,7 +314,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_AccumulatorThrows()
         {
             var ex = new Exception();
@@ -343,7 +344,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithSeedAndResult_ResultSelectorThrows()
         {
             var ex = new Exception();
@@ -373,7 +374,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithoutSeed_Empty()
         {
             var scheduler = new TestScheduler();
@@ -396,7 +397,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithoutSeed_Return()
         {
             var scheduler = new TestScheduler();
@@ -421,7 +422,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithoutSeed_Throw()
         {
             var ex = new Exception();
@@ -446,7 +447,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithoutSeed_Never()
         {
             var scheduler = new TestScheduler();
@@ -463,7 +464,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithoutSeed_Range()
         {
             var scheduler = new TestScheduler();
@@ -492,7 +493,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AggregateWithoutSeed_AccumulatorThrows()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AllTest.cs

@@ -8,20 +8,21 @@ using System.Reactive;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AllTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void All_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.All(DummyObservable<int>.Instance, default));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.All(default(IObservable<int>), x => true));
         }
 
-        [Fact]
+        [TestMethod]
         public void All_Empty()
         {
             var scheduler = new TestScheduler();
@@ -45,7 +46,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_Return()
         {
             var scheduler = new TestScheduler();
@@ -70,7 +71,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_ReturnNotMatch()
         {
             var scheduler = new TestScheduler();
@@ -95,7 +96,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_SomeNoneMatch()
         {
             var scheduler = new TestScheduler();
@@ -122,7 +123,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_SomeMatch()
         {
             var scheduler = new TestScheduler();
@@ -149,7 +150,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_SomeAllMatch()
         {
             var scheduler = new TestScheduler();
@@ -176,7 +177,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_Throw()
         {
             var ex = new Exception();
@@ -201,7 +202,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_Never()
         {
             var ex = new Exception();
@@ -224,7 +225,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void All_PredicateThrows()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AmbTest.cs

@@ -8,14 +8,17 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AmbTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Amb_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Amb((IObservable<int>[])null));
@@ -24,7 +27,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Amb(DummyObservable<int>.Instance, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Never2()
         {
             var scheduler = new TestScheduler();
@@ -53,7 +56,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Never3()
         {
             var scheduler = new TestScheduler();
@@ -90,7 +93,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Never3_Params()
         {
             var scheduler = new TestScheduler();
@@ -127,7 +130,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_NeverEmpty()
         {
             var scheduler = new TestScheduler();
@@ -158,7 +161,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_EmptyNever()
         {
             var scheduler = new TestScheduler();
@@ -189,7 +192,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_RegularShouldDisposeLoser()
         {
             var scheduler = new TestScheduler();
@@ -224,7 +227,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_WinnerThrows()
         {
             var scheduler = new TestScheduler();
@@ -261,7 +264,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_LoserThrows()
         {
             var scheduler = new TestScheduler();
@@ -298,7 +301,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_ThrowsBeforeElectionLeft()
         {
             var scheduler = new TestScheduler();
@@ -333,7 +336,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_ThrowsBeforeElectionRight()
         {
             var scheduler = new TestScheduler();
@@ -368,7 +371,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Array_OnNext()
         {
             var scheduler = new TestScheduler();
@@ -413,7 +416,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Array_OnError()
         {
             var scheduler = new TestScheduler();
@@ -455,7 +458,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Array_OnCompleted()
         {
             var scheduler = new TestScheduler();
@@ -500,7 +503,7 @@ namespace ReactiveTests.Tests
         }
 
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Enumerable_OnNext()
         {
             var scheduler = new TestScheduler();
@@ -545,7 +548,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Enumerable_OnError()
         {
             var scheduler = new TestScheduler();
@@ -587,7 +590,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Enumerable_OnCompleted()
         {
             var scheduler = new TestScheduler();
@@ -632,7 +635,7 @@ namespace ReactiveTests.Tests
         }
 
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Enumerable_Many_Sources()
         {
             for (var i = 0; i < 32; i++)
@@ -657,7 +660,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Amb_Many_Enumerable_Many_Sources_NoStackOverflow()
         {
             for (var i = 0; i < 100; i++)

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AndTest.cs

@@ -6,14 +6,15 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AndTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void And_ArgumentChecking()
         {
             var someObservable = Observable.Return(1);
@@ -36,7 +37,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.And(someObservable, someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And(someObservable).And<int>(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void And2()
         {
             var scheduler = new TestScheduler();
@@ -62,7 +63,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And2Error()
         {
             var ex = new Exception();
@@ -101,7 +102,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And3()
         {
             var scheduler = new TestScheduler();
@@ -127,7 +128,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And3Error()
         {
             var ex = new Exception();
@@ -166,7 +167,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And4()
         {
             var scheduler = new TestScheduler();
@@ -192,7 +193,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And4Error()
         {
             var ex = new Exception();
@@ -231,7 +232,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And5()
         {
             var scheduler = new TestScheduler();
@@ -257,7 +258,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And5Error()
         {
             var ex = new Exception();
@@ -296,7 +297,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And6()
         {
             var scheduler = new TestScheduler();
@@ -322,7 +323,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And6Error()
         {
             var ex = new Exception();
@@ -361,7 +362,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And7()
         {
             var scheduler = new TestScheduler();
@@ -387,7 +388,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And7Error()
         {
             var ex = new Exception();
@@ -426,7 +427,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And8()
         {
             var scheduler = new TestScheduler();
@@ -452,7 +453,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And8Error()
         {
             var ex = new Exception();
@@ -491,7 +492,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And9()
         {
             var scheduler = new TestScheduler();
@@ -517,7 +518,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And9Error()
         {
             var ex = new Exception();
@@ -556,7 +557,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And10()
         {
             var scheduler = new TestScheduler();
@@ -582,7 +583,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And10Error()
         {
             var ex = new Exception();
@@ -621,7 +622,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And11()
         {
             var scheduler = new TestScheduler();
@@ -647,7 +648,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And11Error()
         {
             var ex = new Exception();
@@ -686,7 +687,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And12()
         {
             var scheduler = new TestScheduler();
@@ -712,7 +713,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And12Error()
         {
             var ex = new Exception();
@@ -751,7 +752,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And13()
         {
             var scheduler = new TestScheduler();
@@ -777,7 +778,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And13Error()
         {
             var ex = new Exception();
@@ -816,7 +817,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And14()
         {
             var scheduler = new TestScheduler();
@@ -842,7 +843,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And14Error()
         {
             var ex = new Exception();
@@ -881,7 +882,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And15()
         {
             var scheduler = new TestScheduler();
@@ -907,7 +908,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And15Error()
         {
             var ex = new Exception();
@@ -946,7 +947,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void And16()
         {
             var scheduler = new TestScheduler();
@@ -972,7 +973,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void And16Error()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AnyTest.cs

@@ -7,13 +7,14 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AnyTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Any_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Any(default(IObservable<int>)));
@@ -21,7 +22,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Any(default(IObservable<int>), x => true));
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Empty()
         {
             var scheduler = new TestScheduler();
@@ -45,7 +46,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Return()
         {
             var scheduler = new TestScheduler();
@@ -70,7 +71,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Throw()
         {
             var ex = new Exception();
@@ -95,7 +96,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Never()
         {
             var ex = new Exception();
@@ -118,7 +119,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_Empty()
         {
             var scheduler = new TestScheduler();
@@ -142,7 +143,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_Return()
         {
             var scheduler = new TestScheduler();
@@ -167,7 +168,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_ReturnNotMatch()
         {
             var scheduler = new TestScheduler();
@@ -192,7 +193,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_SomeNoneMatch()
         {
             var scheduler = new TestScheduler();
@@ -219,7 +220,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_SomeMatch()
         {
             var scheduler = new TestScheduler();
@@ -246,7 +247,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_Throw()
         {
             var ex = new Exception();
@@ -271,7 +272,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_Never()
         {
             var scheduler = new TestScheduler();
@@ -292,7 +293,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Any_Predicate_PredicateThrows()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendPrependTest.cs

@@ -6,13 +6,16 @@ using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AppendPrependTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void AppendPrepend()
         {
             var scheduler = new TestScheduler();
@@ -35,7 +38,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void PrependAppend()
         {
             var scheduler = new TestScheduler();
@@ -58,7 +61,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -81,7 +84,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void PrependAppend_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -104,7 +107,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_Many()
         {
             var scheduler = new TestScheduler();
@@ -131,7 +134,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void PrependAppend_Many()
         {
             var scheduler = new TestScheduler();
@@ -158,7 +161,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_Many_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -190,7 +193,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void PrependAppend_Many_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -222,7 +225,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_Mixed()
         {
             var scheduler = new TestScheduler();
@@ -249,7 +252,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_Mixed_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -281,7 +284,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_MixedSchedulers()
         {
             var scheduler = new TestScheduler();
@@ -313,7 +316,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_SchedulerRecursive()
         {
             using var scheduler = new EventLoopScheduler();
@@ -333,7 +336,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void AppendPrepend_SchedulerLongRunning()
         {
             var scheduler = NewThreadScheduler.Default;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendTest.cs

@@ -6,13 +6,14 @@ using System;
 using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AppendTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Append_ArgumentChecking()
         {
             var scheduler = new TestScheduler();
@@ -24,7 +25,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Append(someObservable, 1, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Append()
         {
             var scheduler = new TestScheduler();
@@ -46,7 +47,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Append_Null()
         {
             var scheduler = new TestScheduler();
@@ -68,7 +69,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Append_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -90,7 +91,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Append_Many()
         {
             var scheduler = new TestScheduler();
@@ -114,7 +115,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Append_Many_Take()
         {
             var scheduler = new TestScheduler();
@@ -136,7 +137,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Append_Many_Scheduler()
         {
             var scheduler = new TestScheduler();
@@ -160,7 +161,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Append_Many_Take_Scheduler()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AsObservableTest.cs

@@ -5,20 +5,23 @@
 using System;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AsObservableTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.AsObservable<int>(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_AsObservable()
         {
             var scheduler = new TestScheduler();
@@ -47,7 +50,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_Hides()
         {
             var xs = Observable.Empty<int>();
@@ -57,7 +60,7 @@ namespace ReactiveTests.Tests
             Assert.NotSame(xs, res);
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_Never()
         {
             var scheduler = new TestScheduler();
@@ -72,7 +75,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_Empty()
         {
             var scheduler = new TestScheduler();
@@ -95,7 +98,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_Throw()
         {
             var scheduler = new TestScheduler();
@@ -119,7 +122,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_Return()
         {
             var scheduler = new TestScheduler();
@@ -144,7 +147,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void AsObservable_IsNotEager()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AutoConnectTest.cs

@@ -8,13 +8,16 @@ using System.Linq;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AutoConnectTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void AutoConnect_Basic()
         {
             var called = 0;
@@ -40,7 +43,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(new List<int>() { 1, 2, 3, 4, 5 }, list);
         }
 
-        [Fact]
+        [TestMethod]
         public void AutoConnect_Immediately()
         {
             var called = 0;
@@ -66,7 +69,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(new List<int>() { 1, 2, 3, 4, 5 }, list);
         }
 
-        [Fact]
+        [TestMethod]
         public void AutoConnect_TwoConsumers()
         {
             var called = 0;
@@ -101,7 +104,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(new List<int>() { 1, 2, 3, 4, 5 }, list);
         }
 
-        [Fact]
+        [TestMethod]
         public void AutoConnect_Dispose()
         {
             var subject = new Subject<int>();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AverageTest.cs

@@ -7,13 +7,14 @@ using System.Linq;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AverageTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Average_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Average(default(IObservable<int>)));
@@ -50,7 +51,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Average(Observable.Empty<DateTime>(), default(Func<DateTime, long?>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int32_Empty()
         {
             var scheduler = new TestScheduler();
@@ -73,7 +74,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int32_Return()
         {
             var scheduler = new TestScheduler();
@@ -98,7 +99,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int32_Some()
         {
             var scheduler = new TestScheduler();
@@ -125,7 +126,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int32_Throw()
         {
             var ex = new Exception();
@@ -150,7 +151,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int32_Never()
         {
             var ex = new Exception();
@@ -173,7 +174,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int64_Empty()
         {
             var scheduler = new TestScheduler();
@@ -196,7 +197,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int64_Return()
         {
             var scheduler = new TestScheduler();
@@ -221,7 +222,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int64_Some()
         {
             var scheduler = new TestScheduler();
@@ -248,7 +249,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int64_Throw()
         {
             var ex = new Exception();
@@ -273,7 +274,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Int64_Never()
         {
             var ex = new Exception();
@@ -296,7 +297,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Double_Empty()
         {
             var scheduler = new TestScheduler();
@@ -319,7 +320,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Double_Return()
         {
             var scheduler = new TestScheduler();
@@ -344,7 +345,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Double_Some()
         {
             var scheduler = new TestScheduler();
@@ -371,7 +372,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Double_Throw()
         {
             var ex = new Exception();
@@ -396,7 +397,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Double_Never()
         {
             var ex = new Exception();
@@ -419,7 +420,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Float_Empty()
         {
             var scheduler = new TestScheduler();
@@ -442,7 +443,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Float_Return()
         {
             var scheduler = new TestScheduler();
@@ -467,7 +468,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Float_Some()
         {
             var scheduler = new TestScheduler();
@@ -494,7 +495,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Float_Throw()
         {
             var ex = new Exception();
@@ -519,7 +520,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Float_Never()
         {
             var ex = new Exception();
@@ -542,7 +543,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Decimal_Empty()
         {
             var scheduler = new TestScheduler();
@@ -565,7 +566,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Decimal_Return()
         {
             var scheduler = new TestScheduler();
@@ -590,7 +591,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Decimal_Some()
         {
             var scheduler = new TestScheduler();
@@ -617,7 +618,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Decimal_Throw()
         {
             var ex = new Exception();
@@ -642,7 +643,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Decimal_Never()
         {
             var ex = new Exception();
@@ -665,7 +666,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int32_Empty()
         {
             var scheduler = new TestScheduler();
@@ -689,7 +690,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int32_Return()
         {
             var scheduler = new TestScheduler();
@@ -714,7 +715,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int32_Some()
         {
             var scheduler = new TestScheduler();
@@ -741,7 +742,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int32_Throw()
         {
             var ex = new Exception();
@@ -766,7 +767,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int32_Never()
         {
             var ex = new Exception();
@@ -789,7 +790,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int64_Empty()
         {
             var scheduler = new TestScheduler();
@@ -813,7 +814,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int64_Return()
         {
             var scheduler = new TestScheduler();
@@ -838,7 +839,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int64_Some()
         {
             var scheduler = new TestScheduler();
@@ -865,7 +866,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int64_Throw()
         {
             var ex = new Exception();
@@ -890,7 +891,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Int64_Never()
         {
             var ex = new Exception();
@@ -913,7 +914,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Double_Empty()
         {
             var scheduler = new TestScheduler();
@@ -937,7 +938,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Double_Return()
         {
             var scheduler = new TestScheduler();
@@ -962,7 +963,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Double_Some()
         {
             var scheduler = new TestScheduler();
@@ -989,7 +990,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Double_Throw()
         {
             var ex = new Exception();
@@ -1014,7 +1015,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Double_Never()
         {
             var ex = new Exception();
@@ -1037,7 +1038,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Float_Empty()
         {
             var scheduler = new TestScheduler();
@@ -1061,7 +1062,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Float_Return()
         {
             var scheduler = new TestScheduler();
@@ -1086,7 +1087,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Float_Some()
         {
             var scheduler = new TestScheduler();
@@ -1113,7 +1114,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Float_Throw()
         {
             var ex = new Exception();
@@ -1138,7 +1139,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Float_Never()
         {
             var ex = new Exception();
@@ -1161,7 +1162,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Decimal_Empty()
         {
             var scheduler = new TestScheduler();
@@ -1185,7 +1186,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Decimal_Return()
         {
             var scheduler = new TestScheduler();
@@ -1210,7 +1211,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Decimal_Some()
         {
             var scheduler = new TestScheduler();
@@ -1237,7 +1238,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Decimal_Throw()
         {
             var ex = new Exception();
@@ -1262,7 +1263,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Nullable_Decimal_Never()
         {
             var ex = new Exception();
@@ -1287,7 +1288,7 @@ namespace ReactiveTests.Tests
 
 #if !NO_PERF
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Int32()
         {
             var xs = Observable.Return(42, ThreadPoolScheduler.Instance);
@@ -1297,7 +1298,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Int64()
         {
             var xs = Observable.Return(42L, ThreadPoolScheduler.Instance);
@@ -1307,7 +1308,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Double()
         {
             var xs = Observable.Return(42.0, ThreadPoolScheduler.Instance);
@@ -1317,7 +1318,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Single()
         {
             var xs = Observable.Return(42.0f, ThreadPoolScheduler.Instance);
@@ -1327,7 +1328,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Decimal()
         {
             var xs = Observable.Return(42.0m, ThreadPoolScheduler.Instance);
@@ -1337,7 +1338,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Int32_Nullable()
         {
             var xs = Observable.Return((int?)42, ThreadPoolScheduler.Instance);
@@ -1347,7 +1348,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Int64_Nullable()
         {
             var xs = Observable.Return((long?)42L, ThreadPoolScheduler.Instance);
@@ -1357,7 +1358,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Double_Nullable()
         {
             var xs = Observable.Return((double?)42.0, ThreadPoolScheduler.Instance);
@@ -1367,7 +1368,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Single_Nullable()
         {
             var xs = Observable.Return((float?)42.0f, ThreadPoolScheduler.Instance);
@@ -1377,7 +1378,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<OverflowException>(() => res.ForEach(_ => { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_InjectOverflow_Decimal_Nullable()
         {
             var xs = Observable.Return((decimal?)42.0m, ThreadPoolScheduler.Instance);
@@ -1410,7 +1411,7 @@ namespace ReactiveTests.Tests
 #endif
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Int32()
         {
             var scheduler = new TestScheduler();
@@ -1434,7 +1435,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Int64()
         {
             var scheduler = new TestScheduler();
@@ -1458,7 +1459,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Single()
         {
             var scheduler = new TestScheduler();
@@ -1482,7 +1483,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Double()
         {
             var scheduler = new TestScheduler();
@@ -1506,7 +1507,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Decimal()
         {
             var scheduler = new TestScheduler();
@@ -1530,7 +1531,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Int32_Nullable()
         {
             var scheduler = new TestScheduler();
@@ -1554,7 +1555,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Int64_Nullable()
         {
             var scheduler = new TestScheduler();
@@ -1578,7 +1579,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Single_Nullable()
         {
             var scheduler = new TestScheduler();
@@ -1602,7 +1603,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Double_Nullable()
         {
             var scheduler = new TestScheduler();
@@ -1626,7 +1627,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Average_Selector_Regular_Decimal_Nullable()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AwaitTest.cs

@@ -9,13 +9,16 @@ using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class AwaitTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Await_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter(default(IObservable<int>)));
@@ -24,7 +27,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter(Observable.Empty<int>()).OnCompleted(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Await()
         {
             SynchronizationContext.SetSynchronizationContext(null);
@@ -57,7 +60,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Await_Connectable()
         {
             SynchronizationContext.SetSynchronizationContext(null);
@@ -92,7 +95,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(42, result);
         }
 
-        [Fact]
+        [TestMethod]
         public void Await_Error()
         {
             SynchronizationContext.SetSynchronizationContext(null);
@@ -125,7 +128,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Await_Never()
         {
             SynchronizationContext.SetSynchronizationContext(null);
@@ -157,7 +160,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Await_Empty()
         {
             SynchronizationContext.SetSynchronizationContext(null);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/BufferTest.cs

@@ -9,15 +9,16 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class BufferTest : ReactiveTest
     {
         #region + Boundary +
 
-        [Fact]
+        [TestMethod]
         public void Buffer_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Buffer(default(IObservable<int>), DummyFunc<IObservable<int>>.Instance));
@@ -29,7 +30,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Buffer(DummyObservable<int>.Instance, default(IObservable<int>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_Basic()
         {
             var scheduler = new TestScheduler();
@@ -66,7 +67,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_InnerSubscriptions()
         {
             var scheduler = new TestScheduler();
@@ -139,7 +140,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_Empty()
         {
             var scheduler = new TestScheduler();
@@ -177,7 +178,7 @@ namespace ReactiveTests.Tests
         }
 
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -212,7 +213,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_Error()
         {
             var scheduler = new TestScheduler();
@@ -250,7 +251,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_Throw()
         {
             var scheduler = new TestScheduler();
@@ -284,7 +285,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Closings_WindowClose_Error()
         {
             var scheduler = new TestScheduler();
@@ -318,7 +319,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_OpeningClosings_Basic()
         {
             var scheduler = new TestScheduler();
@@ -372,7 +373,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Boundaries_Simple()
         {
             var scheduler = new TestScheduler();
@@ -423,7 +424,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Boundaries_OnCompletedBoundaries()
         {
             var scheduler = new TestScheduler();
@@ -470,7 +471,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Boundaries_OnErrorSource()
         {
             var ex = new Exception();
@@ -515,7 +516,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Boundaries_OnErrorBoundaries()
         {
             var ex = new Exception();
@@ -567,7 +568,7 @@ namespace ReactiveTests.Tests
 
         #region + Count +
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Single_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -580,7 +581,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Buffer(someObservable, 0, 1));
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Count_PartialWindow()
         {
             var scheduler = new TestScheduler();
@@ -608,7 +609,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Count_FullWindows()
         {
             var scheduler = new TestScheduler();
@@ -637,7 +638,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Count_FullAndPartialWindows()
         {
             var scheduler = new TestScheduler();
@@ -666,7 +667,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Count_Error()
         {
             var scheduler = new TestScheduler();
@@ -695,7 +696,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Count_Skip_Less()
         {
             var scheduler = new TestScheduler();
@@ -726,7 +727,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Count_Skip_More()
         {
             var scheduler = new TestScheduler();
@@ -755,7 +756,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithCount_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Buffer(default(IObservable<int>), 1, 1));
@@ -765,7 +766,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Buffer(DummyObservable<int>.Instance, 0));
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithCount_Basic()
         {
             var scheduler = new TestScheduler();
@@ -800,7 +801,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithCount_Disposed()
         {
             var scheduler = new TestScheduler();
@@ -832,7 +833,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithCount_Error()
         {
             var scheduler = new TestScheduler();
@@ -868,7 +869,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithCount_Default()
         {
             Observable.Range(1, 10).Buffer(3).Skip(1).First().AssertEqual(4, 5, 6);
@@ -879,7 +880,7 @@ namespace ReactiveTests.Tests
 
         #region + Time +
 
-        [Fact]
+        [TestMethod]
         public void Buffer_Time_ArgumentChecking()
         {
             var scheduler = new TestScheduler();
@@ -893,7 +894,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Buffer(default(IObservable<int>), TimeSpan.Zero, TimeSpan.Zero, scheduler));
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Buffer(default(IObservable<int>), TimeSpan.FromTicks(1), TimeSpan.FromTicks(1), DummyScheduler.Instance));
@@ -910,7 +911,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Buffer(DummyObservable<int>.Instance, TimeSpan.FromTicks(-1)));
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Basic1()
         {
             var scheduler = new TestScheduler();
@@ -947,7 +948,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Basic2()
         {
             var scheduler = new TestScheduler();
@@ -982,7 +983,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Error()
         {
             var scheduler = new TestScheduler();
@@ -1020,7 +1021,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Disposed()
         {
             var scheduler = new TestScheduler();
@@ -1052,7 +1053,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Basic_Same()
         {
             var scheduler = new TestScheduler();
@@ -1087,7 +1088,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Basic_Same_Periodic()
         {
             var scheduler = new PeriodicTestScheduler();
@@ -1128,7 +1129,7 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Basic_Same_Periodic_Error()
         {
             var ex = new Exception();
@@ -1169,14 +1170,14 @@ namespace ReactiveTests.Tests
 #endif
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_Default()
         {
             Observable.Range(0, 10).Buffer(TimeSpan.FromDays(1), TimeSpan.FromDays(1)).First().AssertEqual(Enumerable.Range(0, 10));
             Observable.Range(0, 10).Buffer(TimeSpan.FromDays(1)).First().AssertEqual(Enumerable.Range(0, 10));
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTimeOrCount_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Buffer(default(IObservable<int>), TimeSpan.FromTicks(1), 1, DummyScheduler.Instance));
@@ -1188,7 +1189,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Buffer(DummyObservable<int>.Instance, TimeSpan.FromTicks(1), 0));
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTimeOrCount_Basic()
         {
             var scheduler = new TestScheduler();
@@ -1226,7 +1227,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTimeOrCount_Error()
         {
             var scheduler = new TestScheduler();
@@ -1265,7 +1266,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTimeOrCount_Disposed()
         {
             var scheduler = new TestScheduler();
@@ -1299,13 +1300,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTimeOrCount_Default()
         {
             Observable.Range(1, 10, DefaultScheduler.Instance).Buffer(TimeSpan.FromDays(1), 3).Skip(1).First().AssertEqual(4, 5, 6);
         }
 
-        [Fact]
+        [TestMethod]
         public void BufferWithTime_TickWhileOnCompleted()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CaseTest.cs

@@ -8,14 +8,15 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CaseTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Case_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Case(null, new Dictionary<int, IObservable<int>>(), DummyObservable<int>.Instance));
@@ -30,7 +31,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Case<int, int>(DummyFunc<int>.Instance, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Case_One()
         {
             var scheduler = new TestScheduler();
@@ -82,7 +83,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Case_Two()
         {
             var scheduler = new TestScheduler();
@@ -134,7 +135,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Case_Three()
         {
             var scheduler = new TestScheduler();
@@ -186,7 +187,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Case_Throw()
         {
             var scheduler = new TestScheduler();
@@ -236,7 +237,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CaseWithDefault_One()
         {
             var scheduler = new TestScheduler();
@@ -278,7 +279,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CaseWithDefault_Two()
         {
             var scheduler = new TestScheduler();
@@ -320,7 +321,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CaseWithDefault_Three()
         {
             var scheduler = new TestScheduler();
@@ -358,7 +359,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CaseWithDefault_Throw()
         {
             var scheduler = new TestScheduler();
@@ -398,14 +399,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CaseWithDefault_CheckDefault()
         {
             Observable.Case(() => 1, new Dictionary<int, IObservable<int>>(), DefaultScheduler.Instance)
                 .AssertEqual(Observable.Case(() => 1, new Dictionary<int, IObservable<int>>()));
         }
 
-        [Fact]
+        [TestMethod]
         public void Case_Error()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CastTest.cs

@@ -7,21 +7,22 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CastTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Cast_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Cast<bool>(default));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Cast<bool>(DummyObservable<object>.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Cast_Complete()
         {
             var scheduler = new TestScheduler();
@@ -51,7 +52,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Cast_Error()
         {
             var scheduler = new TestScheduler();
@@ -83,7 +84,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Cast_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -112,7 +113,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Cast_NotValid()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CatchTest.cs

@@ -11,14 +11,17 @@ using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CatchTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Catch_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int>(null));
@@ -29,7 +32,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Catch<int, Exception>(DummyObservable<int>.Instance, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_IEofIO_GetEnumeratorThrows()
         {
             var ex = new Exception();
@@ -47,7 +50,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_IEofIO()
         {
             var scheduler = new TestScheduler();
@@ -103,7 +106,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_NoErrors()
         {
             var scheduler = new TestScheduler();
@@ -138,7 +141,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Never()
         {
             var scheduler = new TestScheduler();
@@ -167,7 +170,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Empty()
         {
             var scheduler = new TestScheduler();
@@ -198,7 +201,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Return()
         {
             var scheduler = new TestScheduler();
@@ -231,7 +234,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Error()
         {
             var scheduler = new TestScheduler();
@@ -270,7 +273,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Error_Never()
         {
             var scheduler = new TestScheduler();
@@ -306,7 +309,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Error_Error()
         {
             var scheduler = new TestScheduler();
@@ -345,7 +348,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Multiple()
         {
             var scheduler = new TestScheduler();
@@ -392,7 +395,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_ErrorSpecific_Caught()
         {
             var scheduler = new TestScheduler();
@@ -435,7 +438,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_ErrorSpecific_Uncaught()
         {
             var scheduler = new TestScheduler();
@@ -476,7 +479,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_HandlerThrows()
         {
             var scheduler = new TestScheduler();
@@ -510,7 +513,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Nested_OuterCatches()
         {
             var scheduler = new TestScheduler();
@@ -563,7 +566,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Nested_InnerCatches()
         {
             var scheduler = new TestScheduler();
@@ -616,7 +619,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_ThrowFromNestedCatch()
         {
             var scheduler = new TestScheduler();
@@ -672,7 +675,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_DefaultScheduler_Binary()
         {
             var evt = new ManualResetEvent(false);
@@ -688,7 +691,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, res);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_DefaultScheduler_Nary()
         {
             var evt = new ManualResetEvent(false);
@@ -704,7 +707,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, res);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_DefaultScheduler_NaryEnumerable()
         {
             var evt = new ManualResetEvent(false);
@@ -722,7 +725,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, res);
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_EmptyIterator()
         {
             var scheduler = new TestScheduler();
@@ -736,7 +739,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_IteratorThrows()
         {
             var scheduler = new TestScheduler();
@@ -763,7 +766,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_EnumerableThrows()
         {
             var scheduler = new TestScheduler();
@@ -803,7 +806,7 @@ namespace ReactiveTests.Tests
             throw ex;
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_EnumerableTiming()
         {
             var scheduler = new TestScheduler();
@@ -868,7 +871,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Catch_Enumerable_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -919,7 +922,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Catch_TailRecursive1()
         {
             var create = 0L;
@@ -956,7 +959,7 @@ namespace ReactiveTests.Tests
         }
 
 #if HAS_STACKTRACE && !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Catch_TailRecursive2()
         {
             var f = default(Func<int, IObservable<int>>);
@@ -969,7 +972,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Catch_TailRecursive3()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ChunkifyTest.cs

@@ -8,20 +8,23 @@ using System.Linq;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ChunkifyTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Chunkify_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Chunkify(default(IObservable<int>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Chunkify_Regular1()
         {
             var scheduler = new TestScheduler();
@@ -75,7 +78,7 @@ namespace ReactiveTests.Tests
             Assert.True(res[6].SequenceEqual(new int[] { }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Chunkify_Regular2()
         {
             var scheduler = new TestScheduler();
@@ -119,7 +122,7 @@ namespace ReactiveTests.Tests
             Assert.True(res[1].SequenceEqual(new int[] { 6, 7, 8 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Chunkify_Error()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CollectTest.cs

@@ -8,14 +8,17 @@ using System.Linq;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CollectTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Collect_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -30,7 +33,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Collect(someObservable, () => 0, (x, y) => x, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Collect_Regular1()
         {
             var scheduler = new TestScheduler();
@@ -84,7 +87,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(res[6], new int[] { }.Sum());
         }
 
-        [Fact]
+        [TestMethod]
         public void Collect_Regular2()
         {
             var scheduler = new TestScheduler();
@@ -128,7 +131,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(res[1], new int[] { 6, 7, 8 }.Sum());
         }
 
-        [Fact]
+        [TestMethod]
         public void Collect_InitialCollectorThrows()
         {
             var scheduler = new TestScheduler();
@@ -166,7 +169,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex_, ex);
         }
 
-        [Fact]
+        [TestMethod]
         public void Collect_SecondCollectorThrows()
         {
             var scheduler = new TestScheduler();
@@ -218,7 +221,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex_, ex);
         }
 
-        [Fact]
+        [TestMethod]
         public void Collect_NewCollectorThrows()
         {
             var scheduler = new TestScheduler();
@@ -259,7 +262,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex_, ex);
         }
 
-        [Fact]
+        [TestMethod]
         public void Collect_MergeThrows()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ConcatTest.cs

@@ -13,14 +13,17 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ConcatTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Concat_ArgumentChecking()
         {
             var xs = DummyObservable<int>.Instance;
@@ -35,7 +38,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Concat(null, xs));
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_DefaultScheduler()
         {
             var evt = new ManualResetEvent(false);
@@ -51,7 +54,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(6, sum);
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_IEofIO_DefaultScheduler()
         {
             var evt = new ManualResetEvent(false);
@@ -69,7 +72,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(6, sum);
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_IEofIO_GetEnumeratorThrows()
         {
             var ex = new Exception();
@@ -87,7 +90,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_IEofIO()
         {
             var scheduler = new TestScheduler();
@@ -143,7 +146,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_EmptyEmpty()
         {
             var scheduler = new TestScheduler();
@@ -175,7 +178,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_EmptyNever()
         {
             var scheduler = new TestScheduler();
@@ -205,7 +208,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_NeverEmpty()
         {
             var scheduler = new TestScheduler();
@@ -234,7 +237,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_NeverNever()
         {
             var scheduler = new TestScheduler();
@@ -262,7 +265,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_EmptyThrow()
         {
             var scheduler = new TestScheduler();
@@ -296,7 +299,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ThrowEmpty()
         {
             var scheduler = new TestScheduler();
@@ -329,7 +332,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ThrowThrow()
         {
             var scheduler = new TestScheduler();
@@ -362,7 +365,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ReturnEmpty()
         {
             var scheduler = new TestScheduler();
@@ -396,7 +399,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_EmptyReturn()
         {
             var scheduler = new TestScheduler();
@@ -430,7 +433,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ReturnNever()
         {
             var scheduler = new TestScheduler();
@@ -462,7 +465,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_NeverReturn()
         {
             var scheduler = new TestScheduler();
@@ -492,7 +495,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ReturnReturn()
         {
             var scheduler = new TestScheduler();
@@ -530,7 +533,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ThrowReturn()
         {
             var scheduler = new TestScheduler();
@@ -564,7 +567,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_ReturnThrow()
         {
             var scheduler = new TestScheduler();
@@ -600,7 +603,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_SomeDataSomeData()
         {
             var scheduler = new TestScheduler();
@@ -642,7 +645,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_EnumerableThrows()
         {
             var scheduler = new TestScheduler();
@@ -682,7 +685,7 @@ namespace ReactiveTests.Tests
             throw ex;
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_EnumerableTiming()
         {
             var scheduler = new TestScheduler();
@@ -751,7 +754,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_Enumerable_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -801,7 +804,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_Optimization_DeferEvalTiming()
         {
             var scheduler = new TestScheduler();
@@ -849,7 +852,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(230, invoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void Concat_Optimization_DeferExceptionPropagation()
         {
             var scheduler = new TestScheduler();
@@ -883,7 +886,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Concat_TailRecursive1()
         {
             var create = 0L;
@@ -920,7 +923,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD && !NETCOREAPP1_1 && !NETCOREAPP1_0
-        [Fact]
+        [TestMethod]
         public void Concat_TailRecursive2()
         {
             IObservable<int> f(int x) => Observable.Defer(() => Observable.Return(x, ThreadPoolScheduler.Instance).Concat(f(x + 1)));
@@ -932,7 +935,7 @@ namespace ReactiveTests.Tests
 #endif
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Concat_Task()
         {
             var tss = Observable.Concat(new[] { Task.Factory.StartNew(() => 1), Task.Factory.StartNew(() => 2), Task.Factory.StartNew(() => 3) }.ToObservable());

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ContainsTest.cs

@@ -8,14 +8,15 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ContainsTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Contains_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Contains(default, 42));
@@ -23,7 +24,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Contains(DummyObservable<int>.Instance, 42, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_Empty()
         {
             var scheduler = new TestScheduler();
@@ -47,7 +48,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_ReturnPositive()
         {
             var scheduler = new TestScheduler();
@@ -72,7 +73,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_ReturnNegative()
         {
             var scheduler = new TestScheduler();
@@ -97,7 +98,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_SomePositive()
         {
             var scheduler = new TestScheduler();
@@ -124,7 +125,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_SomeNegative()
         {
             var scheduler = new TestScheduler();
@@ -151,7 +152,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_Throw()
         {
             var ex = new Exception();
@@ -176,7 +177,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_Never()
         {
             var ex = new Exception();
@@ -199,7 +200,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_ComparerThrows()
         {
             var ex = new Exception();
@@ -237,7 +238,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_ComparerContainsValue()
         {
             var ex = new Exception();
@@ -266,7 +267,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Contains_ComparerDoesNotContainValue()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CountTest.cs

@@ -8,13 +8,14 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CountTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void Count_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Count(default(IObservable<int>)));
@@ -22,7 +23,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Count(DummyObservable<int>.Instance, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Empty()
         {
             var scheduler = new TestScheduler();
@@ -46,7 +47,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Return()
         {
             var scheduler = new TestScheduler();
@@ -71,7 +72,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Some()
         {
             var scheduler = new TestScheduler();
@@ -98,7 +99,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Throw()
         {
             var ex = new Exception();
@@ -123,7 +124,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Never()
         {
             var scheduler = new TestScheduler();
@@ -145,7 +146,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_PERF && !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Count_InjectOverflow()
         {
             var xs = Observable.Return(42, ThreadPoolScheduler.Instance);
@@ -156,7 +157,7 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Empty_True()
         {
             var scheduler = new TestScheduler();
@@ -180,7 +181,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Empty_False()
         {
             var scheduler = new TestScheduler();
@@ -204,7 +205,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Return_True()
         {
             var scheduler = new TestScheduler();
@@ -229,7 +230,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Return_False()
         {
             var scheduler = new TestScheduler();
@@ -254,7 +255,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Some_All()
         {
             var scheduler = new TestScheduler();
@@ -281,7 +282,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Some_None()
         {
             var scheduler = new TestScheduler();
@@ -308,7 +309,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Some_Even()
         {
             var scheduler = new TestScheduler();
@@ -335,7 +336,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Throw_True()
         {
             var ex = new Exception();
@@ -360,7 +361,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Throw_False()
         {
             var ex = new Exception();
@@ -385,7 +386,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_Never()
         {
             var scheduler = new TestScheduler();
@@ -406,7 +407,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_PredicateThrows()
         {
             var scheduler = new TestScheduler();
@@ -443,7 +444,7 @@ namespace ReactiveTests.Tests
 
 #if !NO_PERF && !NO_THREAD && !CRIPPLED_REFLECTION
 
-        [Fact]
+        [TestMethod]
         public void Count_Predicate_InjectOverflow()
         {
             var xs = Observable.Return(42, ThreadPoolScheduler.Instance);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateAsyncTest.cs

@@ -12,14 +12,17 @@ using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CreateAsyncTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, Task>)));
@@ -30,7 +33,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, CancellationToken, Task<Action>>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_NullCoalescingAction1()
         {
             var xs = Observable.Create<int>(o =>
@@ -46,7 +49,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_NullCoalescingAction2()
         {
             var xs = Observable.Create<int>((o, ct) =>
@@ -62,7 +65,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_NullCoalescingDisposable1()
         {
             var xs = Observable.Create<int>(o =>
@@ -78,7 +81,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_NullCoalescingDisposable2()
         {
             var xs = Observable.Create<int>((o, ct) =>
@@ -111,7 +114,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Never()
         {
             RunSynchronously(() =>
@@ -155,7 +158,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Completed1()
         {
             RunSynchronously(() =>
@@ -197,7 +200,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Completed2()
         {
             RunSynchronously(() =>
@@ -239,7 +242,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Error1()
         {
             RunSynchronously(() =>
@@ -283,7 +286,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Error2()
         {
             RunSynchronously(() =>
@@ -311,7 +314,7 @@ namespace ReactiveTests.Tests
             throw exception;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Error3()
         {
             RunSynchronously(() =>
@@ -351,7 +354,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Cancel1()
         {
             RunSynchronously(() =>
@@ -393,7 +396,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Cancel2()
         {
             RunSynchronously(() =>
@@ -435,7 +438,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Cancel3()
         {
             RunSynchronously(() =>
@@ -478,7 +481,7 @@ namespace ReactiveTests.Tests
             return tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Cancel4()
         {
             RunSynchronously(() =>
@@ -529,7 +532,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Task_Simple()
         {
             var xs = Observable.Create<int>(observer =>
@@ -547,7 +550,7 @@ namespace ReactiveTests.Tests
             Assert.True(new[] { 42 }.SequenceEqual(lst));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Task_Token()
         {
             var e = new ManualResetEvent(false);
@@ -571,15 +574,25 @@ namespace ReactiveTests.Tests
             });
 
             var lst = new List<int>();
-            var d = xs.Subscribe(lst.Add);
+            var d = xs.Subscribe(i => { lock (lst) { lst.Add(i); } });
 
             e.WaitOne();
             d.Dispose();
 
-            Assert.True(lst.Take(10).SequenceEqual(Enumerable.Repeat(42, 10)));
+            // Although Dispose will set the _isStopped gate in the AutoDetachObserver that our
+            // observer gets wrapped in, it's possible that the thread we kicked off had just
+            // made one of its calls to observer.OnNext, and that this had just got past the
+            // _isStopped gate when we called Dispose, meaning that it might right now be inside
+            // List<int>.Add. We're synchronizing access to the list to ensure that any such
+            // call has completed by the time we try to inspect the list.
+
+            lock (lst)
+            {
+                Assert.True(lst.Take(10).SequenceEqual(Enumerable.Repeat(42, 10)));
+            }
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_IDisposable_Simple()
         {
             var stopped = new ManualResetEvent(false);
@@ -604,7 +617,7 @@ namespace ReactiveTests.Tests
             Assert.True(new[] { 42 }.SequenceEqual(lst));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_IDisposable_Token()
         {
             var stopped = new ManualResetEvent(false);
@@ -642,7 +655,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.Take(10).SequenceEqual(Enumerable.Repeat(42, 10)));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Action_Simple()
         {
             var stopped = new ManualResetEvent(false);
@@ -667,7 +680,7 @@ namespace ReactiveTests.Tests
             Assert.True(new[] { 42 }.SequenceEqual(lst));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateAsync_Action_Token()
         {
             var stopped = new ManualResetEvent(false);
@@ -706,7 +719,7 @@ namespace ReactiveTests.Tests
         }
 
 
-        [Fact]
+        [TestMethod]
         public void CreateWithTaskDisposable_NoPrematureTermination()
         {
             var obs = Observable.Create<int>(async o =>
@@ -725,7 +738,7 @@ namespace ReactiveTests.Tests
             var result = obs.Take(1).Wait();
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithTaskAction_NoPrematureTermination()
         {
             var obs = Observable.Create<int>(async o =>

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateTest.cs

@@ -11,14 +11,17 @@ using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class CreateTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Create_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, Action>)));
@@ -37,7 +40,7 @@ namespace ReactiveTests.Tests
             }).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_NullCoalescingAction()
         {
             var xs = Observable.Create<int>(o =>
@@ -53,7 +56,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_Next()
         {
             var scheduler = new TestScheduler();
@@ -73,7 +76,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_Completed()
         {
             var scheduler = new TestScheduler();
@@ -94,7 +97,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_Error()
         {
             var scheduler = new TestScheduler();
@@ -117,14 +120,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_Exception()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
                 Observable.Create(new Func<IObserver<int>, Action>(o => { throw new InvalidOperationException(); })).Subscribe());
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -177,7 +180,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Create_ObserverThrows()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
@@ -200,7 +203,7 @@ namespace ReactiveTests.Tests
                 }).Subscribe(x => { }, ex => { }, () => { throw new InvalidOperationException(); }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Create(default(Func<IObserver<int>, IDisposable>)));
@@ -212,7 +215,7 @@ namespace ReactiveTests.Tests
             }).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_NullCoalescingAction()
         {
             var xs = Observable.Create<int>(o =>
@@ -228,7 +231,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_Next()
         {
             var scheduler = new TestScheduler();
@@ -248,7 +251,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_Completed()
         {
             var scheduler = new TestScheduler();
@@ -269,7 +272,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_Error()
         {
             var scheduler = new TestScheduler();
@@ -292,14 +295,14 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_Exception()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
                 Observable.Create(new Func<IObserver<int>, IDisposable>(o => { throw new InvalidOperationException(); })).Subscribe());
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -352,7 +355,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void CreateWithDisposable_ObserverThrows()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() =>
@@ -375,7 +378,7 @@ namespace ReactiveTests.Tests
                 }).Subscribe(x => { }, ex => { }, () => { throw new InvalidOperationException(); }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create<int>(default));
@@ -397,7 +400,7 @@ namespace ReactiveTests.Tests
             observer.OnNext(4);
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Complete()
         {
             var scheduler = new TestScheduler();
@@ -461,7 +464,7 @@ namespace ReactiveTests.Tests
             observer.OnNext(4);
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Complete_Implicit()
         {
             var scheduler = new TestScheduler();
@@ -533,7 +536,7 @@ namespace ReactiveTests.Tests
             observer.OnCompleted();
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Iterator_Throw()
         {
             var scheduler = new TestScheduler();
@@ -602,7 +605,7 @@ namespace ReactiveTests.Tests
             observer.OnCompleted();
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Iterator_Error()
         {
             var scheduler = new TestScheduler();
@@ -666,7 +669,7 @@ namespace ReactiveTests.Tests
             observer.OnNext(4);
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Complete_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -719,7 +722,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void IteratorScenario()
         {
             var xs = ObservableEx.Create<int>(o => _IteratorScenario(100, 1000, o));
@@ -740,7 +743,7 @@ namespace ReactiveTests.Tests
             results.OnNext(ys.Value);
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Void_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Create(default));
@@ -756,7 +759,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new object());
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Void_Complete()
         {
             var scheduler = new TestScheduler();
@@ -812,7 +815,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new object());
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Void_Complete_Implicit()
         {
             var scheduler = new TestScheduler();
@@ -873,7 +876,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new object());
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Void_Iterator_Throw()
         {
             var scheduler = new TestScheduler();
@@ -930,7 +933,7 @@ namespace ReactiveTests.Tests
             yield return zs.Select(x => new object());
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Void_Complete_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -980,7 +983,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Iterate_Void_Func_Throw()
         {
             var scheduler = new TestScheduler();
@@ -1003,7 +1006,7 @@ namespace ReactiveTests.Tests
             yield return ys;
         }
 
-        [Fact]
+        [TestMethod]
         public void IteratorScenario_Void()
         {
             var xs = ObservableEx.Create(() => _IteratorScenario_Void(100, 1000));

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DefaultIfEmptyTest.cs

@@ -6,21 +6,22 @@ using System;
 using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DefaultIfEmptyTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DefaultIfEmpty(default(IObservable<int>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DefaultIfEmpty(default, 42));
         }
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_NonEmpty1()
         {
             var scheduler = new TestScheduler();
@@ -46,7 +47,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_NonEmpty2()
         {
             var scheduler = new TestScheduler();
@@ -72,7 +73,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_Empty1()
         {
             var scheduler = new TestScheduler();
@@ -95,7 +96,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_Empty2()
         {
             var scheduler = new TestScheduler();
@@ -118,7 +119,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_Throw1()
         {
             var ex = new Exception();
@@ -142,7 +143,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DefaultIfEmpty_Throw2()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferAsyncTest.cs

@@ -8,21 +8,24 @@ using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DeferAsyncTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void DeferAsync_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Defer(default(Func<Task<IObservable<int>>>)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DeferAsync(default(Func<CancellationToken, Task<IObservable<int>>>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void DeferAsync_Simple()
         {
             var xs = Observable.Defer(() => Task.Factory.StartNew(() => Observable.Return(42)));
@@ -32,7 +35,7 @@ namespace ReactiveTests.Tests
             Assert.True(new[] { 42 }.SequenceEqual(res));
         }
 
-        [Fact]
+        [TestMethod]
         public void DeferAsync_WithCancel_Simple()
         {
             var xs = Observable.DeferAsync(ct => Task.Factory.StartNew(() => Observable.Return(42)));
@@ -42,7 +45,7 @@ namespace ReactiveTests.Tests
             Assert.True(new[] { 42 }.SequenceEqual(res));
         }
 
-        [Fact]
+        [TestMethod]
         public void DeferAsync_WithCancel_Cancel()
         {
             var N = 10;// 0000;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferTest.cs

@@ -6,14 +6,17 @@ using System;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DeferTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Defer_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Defer(default(Func<IObservable<int>>)));
@@ -21,7 +24,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws</*some*/Exception>(() => Observable.Defer(() => default(IObservable<int>)).Subscribe());
         }
 
-        [Fact]
+        [TestMethod]
         public void Defer_Complete()
         {
             var scheduler = new TestScheduler();
@@ -52,7 +55,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Defer_Error()
         {
             var scheduler = new TestScheduler();
@@ -84,7 +87,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Defer_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -116,7 +119,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Defer_Throw()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelaySubscriptionTest.cs

@@ -9,14 +9,17 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DelaySubscriptionTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DelaySubscription(default(IObservable<int>), DateTimeOffset.Now));
@@ -31,7 +34,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.DelaySubscription(DummyObservable<int>.Instance, TimeSpan.FromSeconds(-1), Scheduler.Immediate));
         }
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_TimeSpan_Default()
         {
             var lst = new List<int>();
@@ -39,7 +42,7 @@ namespace ReactiveTests.Tests
             Assert.True(Enumerable.Range(0, 10).SequenceEqual(lst));
         }
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_TimeSpan_Simple()
         {
             var scheduler = new TestScheduler();
@@ -65,7 +68,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_TimeSpan_Error()
         {
             var ex = new Exception();
@@ -93,7 +96,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_DateTimeOffset_Default()
         {
             var lst = new List<int>();
@@ -101,7 +104,7 @@ namespace ReactiveTests.Tests
             Assert.True(Enumerable.Range(0, 10).SequenceEqual(lst));
         }
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_DateTimeOffset_Simple()
         {
             var scheduler = new TestScheduler();
@@ -127,7 +130,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DelaySubscription_DateTimeOffset_Error()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelayTest.cs

@@ -14,14 +14,17 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DelayTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Delay_ArgumentChecking()
         {
             var scheduler = new TestScheduler();
@@ -38,13 +41,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.Delay(someObservable, TimeSpan.FromSeconds(-1), scheduler));
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Simple1()
         {
             Delay_TimeSpan_Simple1_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Simple1_Stopwatch()
         {
             Delay_TimeSpan_Simple1_Impl(true);
@@ -78,13 +81,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Simple1()
         {
             Delay_DateTimeOffset_Simple1_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Simple1_Stopwatch()
         {
             Delay_DateTimeOffset_Simple1_Impl(true);
@@ -118,13 +121,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Simple2()
         {
             Delay_TimeSpan_Simple2_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Simple2_Stopwatch()
         {
             Delay_TimeSpan_Simple2_Impl(true);
@@ -158,13 +161,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Simple2()
         {
             Delay_DateTimeOffset_Simple2_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Simple2_Stopwatch()
         {
             Delay_DateTimeOffset_Simple2_Impl(true);
@@ -198,13 +201,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Simple3()
         {
             Delay_TimeSpan_Simple3_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Simple3_Stopwatch()
         {
             Delay_TimeSpan_Simple3_Impl(true);
@@ -238,13 +241,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Simple3()
         {
             Delay_DateTimeOffset_Simple3_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Simple3_Stopwatch()
         {
             Delay_DateTimeOffset_Simple3_Impl(true);
@@ -278,13 +281,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Error1()
         {
             Delay_TimeSpan_Error1_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Error1_Stopwatch()
         {
             Delay_TimeSpan_Error1_Impl(true);
@@ -320,13 +323,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Error1()
         {
             Delay_DateTimeOffset_Error1_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Error1_Stopwatch()
         {
             Delay_DateTimeOffset_Error1_Impl(true);
@@ -362,13 +365,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Error2()
         {
             Delay_TimeSpan_Error2_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Error2_Stopwatch()
         {
             Delay_TimeSpan_Error2_Impl(true);
@@ -403,13 +406,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Error2()
         {
             Delay_DateTimeOffset_Error2_Impl(false);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_Error2_Stopwatch()
         {
             Delay_DateTimeOffset_Error2_Impl(true);
@@ -445,13 +448,13 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Simple1()
         {
             Delay_TimeSpan_Real_Simple1_Impl(ThreadPoolScheduler.Instance.DisableOptimizations());
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Simple1_Stopwatch()
         {
             Delay_TimeSpan_Real_Simple1_Impl(ThreadPoolScheduler.Instance);
@@ -481,13 +484,13 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Error1()
         {
             Delay_TimeSpan_Real_Error1_Impl(ThreadPoolScheduler.Instance.DisableOptimizations());
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Error1_Stopwatch()
         {
             Delay_TimeSpan_Real_Error1_Impl(ThreadPoolScheduler.Instance);
@@ -519,13 +522,13 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Error2()
         {
             Delay_TimeSpan_Real_Error2_Impl(ThreadPoolScheduler.Instance.DisableOptimizations());
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Error2_Stopwatch()
         {
             Delay_TimeSpan_Real_Error2_Impl(ThreadPoolScheduler.Instance);
@@ -558,13 +561,13 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Error3()
         {
             Delay_TimeSpan_Real_Error3_Impl(ThreadPoolScheduler.Instance.DisableOptimizations());
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Real_Error3_Stopwatch()
         {
             Delay_TimeSpan_Real_Error3_Impl(ThreadPoolScheduler.Instance);
@@ -599,7 +602,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_Positive()
         {
             var scheduler = new TestScheduler();
@@ -627,7 +630,7 @@ namespace ReactiveTests.Tests
             res.Messages.AssertEqual(expected);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Empty()
         {
             var scheduler = new TestScheduler();
@@ -650,7 +653,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Error()
         {
             var scheduler = new TestScheduler();
@@ -675,7 +678,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Never()
         {
             var scheduler = new TestScheduler();
@@ -696,19 +699,19 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_TimeSpan_DefaultScheduler()
         {
             Assert.True(Observable.Return(1).Delay(TimeSpan.FromMilliseconds(1)).ToEnumerable().SequenceEqual(new[] { 1 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DateTimeOffset_DefaultScheduler()
         {
             Assert.True(Observable.Return(1).Delay(DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(1)).ToEnumerable().SequenceEqual(new[] { 1 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_CrossingMessages()
         {
             var lst = new List<int>();
@@ -738,7 +741,7 @@ namespace ReactiveTests.Tests
             Assert.True(Enumerable.Range(0, 10).SequenceEqual(lst));
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_ArgumentChecking()
         {
             var someObservable = DummyObservable<int>.Instance;
@@ -750,7 +753,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Delay(someObservable, someObservable, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Simple1()
         {
             var scheduler = new TestScheduler();
@@ -783,7 +786,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Simple2()
         {
             var scheduler = new TestScheduler();
@@ -828,7 +831,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Simple3()
         {
             var scheduler = new TestScheduler();
@@ -873,7 +876,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Simple4_InnerEmpty()
         {
             var scheduler = new TestScheduler();
@@ -918,7 +921,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Dispose1()
         {
             var scheduler = new TestScheduler();
@@ -960,7 +963,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Dispose2()
         {
             var scheduler = new TestScheduler();
@@ -994,7 +997,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_OuterError1()
         {
             var scheduler = new TestScheduler();
@@ -1036,7 +1039,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_OuterError2()
         {
             var scheduler = new TestScheduler();
@@ -1083,7 +1086,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_InnerError1()
         {
             var scheduler = new TestScheduler();
@@ -1131,7 +1134,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_InnerError2()
         {
             var scheduler = new TestScheduler();
@@ -1173,7 +1176,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_SelectorThrows1()
         {
             var scheduler = new TestScheduler();
@@ -1221,7 +1224,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Simple()
         {
             var scheduler = new TestScheduler();
@@ -1255,7 +1258,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_DeferOnCompleted()
         {
             var scheduler = new TestScheduler();
@@ -1289,7 +1292,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_InnerError()
         {
             var scheduler = new TestScheduler();
@@ -1327,7 +1330,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_OuterError()
         {
             var scheduler = new TestScheduler();
@@ -1362,7 +1365,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_SelectorThrows2()
         {
             var scheduler = new TestScheduler();
@@ -1405,7 +1408,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_Selector_Immediately()
         {
             var list = new List<int>();
@@ -1417,7 +1420,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(new List<int>() { 1, 2, 3, 4, 5 }, list);
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_InnerDone()
         {
             var scheduler = new TestScheduler();
@@ -1452,7 +1455,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Duration_InnerSubscriptionTimes()
         {
             var scheduler = new TestScheduler();
@@ -1500,7 +1503,7 @@ namespace ReactiveTests.Tests
             ys[2].Subscriptions.AssertEqual(Subscribe(450, 450 + 30));
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DurationAndSubscription_Simple1()
         {
             var scheduler = new TestScheduler();
@@ -1540,7 +1543,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DurationAndSubscription_Simple2()
         {
             var scheduler = new TestScheduler();
@@ -1580,7 +1583,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DurationAndSubscription_Dispose1()
         {
             var scheduler = new TestScheduler();
@@ -1617,7 +1620,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DurationAndSubscription_Dispose2()
         {
             var scheduler = new TestScheduler();
@@ -1652,7 +1655,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_DurationAndSubscription_Error()
         {
             var scheduler = new TestScheduler();
@@ -1689,7 +1692,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_ErrorHandling1()
         {
             //
@@ -1756,7 +1759,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_LongRunning_CancelEarly()
         {
             var xs = Observable.Create<int>(observer =>
@@ -1808,7 +1811,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_LongRunning_CancelLate()
         {
             var xs = Observable.Return(42);
@@ -1825,7 +1828,7 @@ namespace ReactiveTests.Tests
             e.WaitOne();
         }
 
-        [Fact]
+        [TestMethod]
         public void Delay_Selector_Immediate()
         {
             var result = 0;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DematerializeTest.cs

@@ -6,20 +6,21 @@ using System;
 using System.Reactive;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DematerializeTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Dematerialize_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Dematerialize<int>(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Dematerialize_Range1()
         {
             var scheduler = new TestScheduler();
@@ -45,7 +46,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Dematerialize_Range2()
         {
             var scheduler = new TestScheduler();
@@ -71,7 +72,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Dematerialize_Error1()
         {
             var scheduler = new TestScheduler();
@@ -99,7 +100,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Dematerialize_Error2()
         {
             var scheduler = new TestScheduler();
@@ -127,7 +128,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Materialize_Dematerialize_Never()
         {
             var scheduler = new TestScheduler();
@@ -142,7 +143,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Materialize_Dematerialize_Empty()
         {
             var scheduler = new TestScheduler();
@@ -165,7 +166,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Materialize_Dematerialize_Return()
         {
             var scheduler = new TestScheduler();
@@ -190,7 +191,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Materialize_Dematerialize_Throw()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctTest.cs

@@ -8,14 +8,15 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DistinctTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Distinct_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Distinct(default(IObservable<int>)));
@@ -28,7 +29,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Distinct(DummyObservable<int>.Instance, x => x, default(EqualityComparer<int>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_DefaultComparer_AllDistinct()
         {
             var scheduler = new TestScheduler();
@@ -60,7 +61,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_DefaultComparer_SomeDuplicates()
         {
             var scheduler = new TestScheduler();
@@ -90,7 +91,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_CustomComparer_AllDistinct()
         {
             var scheduler = new TestScheduler();
@@ -122,7 +123,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_CustomComparer_SomeDuplicates()
         {
             var scheduler = new TestScheduler();
@@ -172,7 +173,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_KeySelector_DefaultComparer_AllDistinct()
         {
             var scheduler = new TestScheduler();
@@ -204,7 +205,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_KeySelector_DefaultComparer_SomeDuplicates()
         {
             var scheduler = new TestScheduler();
@@ -234,7 +235,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_KeySelector_CustomComparer_AllDistinct()
         {
             var scheduler = new TestScheduler();
@@ -266,7 +267,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_KeySelector_CustomComparer_SomeDuplicates()
         {
             var scheduler = new TestScheduler();
@@ -296,7 +297,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_KeySelector_Throws()
         {
             var scheduler = new TestScheduler();
@@ -327,7 +328,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_CustomComparer_Throws()
         {
             var scheduler = new TestScheduler();
@@ -386,7 +387,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_Throw()
         {
             var scheduler = new TestScheduler();
@@ -416,7 +417,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Distinct_Null()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctUntilChangedTest.cs

@@ -6,14 +6,15 @@ using System;
 using System.Collections.Generic;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DistinctUntilChangedTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -28,7 +29,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DistinctUntilChanged(someObservable, null, EqualityComparer<int>.Default));
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_Never()
         {
             var scheduler = new TestScheduler();
@@ -43,7 +44,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_Empty()
         {
             var scheduler = new TestScheduler();
@@ -66,7 +67,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_Return()
         {
             var scheduler = new TestScheduler();
@@ -91,7 +92,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_Throw()
         {
             var scheduler = new TestScheduler();
@@ -115,7 +116,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_AllChanges()
         {
             var scheduler = new TestScheduler();
@@ -146,7 +147,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_AllSame()
         {
             var scheduler = new TestScheduler();
@@ -174,7 +175,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_SomeChanges()
         {
             var scheduler = new TestScheduler();
@@ -209,7 +210,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_Comparer_AllEqual()
         {
             var scheduler = new TestScheduler();
@@ -237,7 +238,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_Comparer_AllDifferent()
         {
             var scheduler = new TestScheduler();
@@ -268,7 +269,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_KeySelector_Div2()
         {
             var scheduler = new TestScheduler();
@@ -317,7 +318,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_KeySelectorThrows()
         {
             var ex = new Exception();
@@ -339,7 +340,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_ComparerThrows()
         {
             var ex = new Exception();
@@ -383,7 +384,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void DistinctUntilChanged_KeySelector_Comparer()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoTest.cs

@@ -6,14 +6,17 @@ using System;
 using System.Reactive;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DoTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Do_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -34,7 +37,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Do(someObservable, default(IObserver<int>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_ShouldSeeAllValues()
         {
             var scheduler = new TestScheduler();
@@ -70,7 +73,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_PlainAction()
         {
             var scheduler = new TestScheduler();
@@ -104,7 +107,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextCompleted()
         {
             var scheduler = new TestScheduler();
@@ -142,7 +145,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextCompleted_Never()
         {
             var scheduler = new TestScheduler();
@@ -166,7 +169,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextError()
         {
             var scheduler = new TestScheduler();
@@ -206,7 +209,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextErrorNot()
         {
             var scheduler = new TestScheduler();
@@ -244,7 +247,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextErrorCompleted()
         {
             var scheduler = new TestScheduler();
@@ -284,7 +287,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextErrorCompletedError()
         {
             var scheduler = new TestScheduler();
@@ -326,7 +329,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_NextErrorCompletedNever()
         {
             var scheduler = new TestScheduler();
@@ -352,7 +355,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_Observer_SomeDataWithError()
         {
             var scheduler = new TestScheduler();
@@ -394,7 +397,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do_Observer_SomeDataWithoutError()
         {
             var scheduler = new TestScheduler();
@@ -434,7 +437,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_Next_NextThrows()
         {
             var scheduler = new TestScheduler();
@@ -460,7 +463,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextCompleted_NextThrows()
         {
             var scheduler = new TestScheduler();
@@ -486,7 +489,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextCompleted_CompletedThrows()
         {
             var scheduler = new TestScheduler();
@@ -513,7 +516,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextError_NextThrows()
         {
             var scheduler = new TestScheduler();
@@ -539,7 +542,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextError_ErrorThrows()
         {
             var scheduler = new TestScheduler();
@@ -565,7 +568,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextErrorCompleted_NextThrows()
         {
             var scheduler = new TestScheduler();
@@ -591,7 +594,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextErrorCompleted_ErrorThrows()
         {
             var scheduler = new TestScheduler();
@@ -617,7 +620,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_NextErrorCompleted_CompletedThrows()
         {
             var scheduler = new TestScheduler();
@@ -644,7 +647,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_Observer_NextThrows()
         {
             var scheduler = new TestScheduler();
@@ -670,7 +673,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_Observer_ErrorThrows()
         {
             var scheduler = new TestScheduler();
@@ -696,7 +699,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Do1422_Observer_CompletedThrows()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoWhileTest.cs

@@ -6,21 +6,22 @@ using System;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class DoWhileTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DoWhile(DummyObservable<int>.Instance, null));
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.DoWhile(default(IObservable<int>), DummyFunc<bool>.Instance));
         }
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_AlwaysFalse()
         {
             var scheduler = new TestScheduler();
@@ -48,7 +49,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_AlwaysTrue()
         {
             var scheduler = new TestScheduler();
@@ -86,7 +87,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_AlwaysTrue_Throw()
         {
             var scheduler = new TestScheduler();
@@ -108,7 +109,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_AlwaysTrue_Infinite()
         {
             var scheduler = new TestScheduler();
@@ -128,7 +129,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_SometimesTrue()
         {
             var scheduler = new TestScheduler();
@@ -168,7 +169,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void DoWhile_SometimesThrows()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtOrDefaultTest.cs

@@ -7,21 +7,22 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ElementAtOrDefaultTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void ElementAtOrDefault_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ElementAtOrDefault(default(IObservable<int>), 2));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.ElementAtOrDefault(DummyObservable<int>.Instance, -1));
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAtOrDefault_First()
         {
             var scheduler = new TestScheduler();
@@ -47,7 +48,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAtOrDefault_Other()
         {
             var scheduler = new TestScheduler();
@@ -73,7 +74,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAtOrDefault_OutOfRange()
         {
             var scheduler = new TestScheduler();
@@ -99,7 +100,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAtOrDefault_Error()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtTest.cs

@@ -7,21 +7,22 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ElementAtTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void ElementAt_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ElementAt(default(IObservable<int>), 2));
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => Observable.ElementAt(DummyObservable<int>.Instance, -1));
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAt_First()
         {
             var scheduler = new TestScheduler();
@@ -47,7 +48,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAt_Other()
         {
             var scheduler = new TestScheduler();
@@ -73,7 +74,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAt_OutOfRange()
         {
             var scheduler = new TestScheduler();
@@ -94,7 +95,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ElementAt_Error()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/EmptyTest.cs

@@ -8,14 +8,17 @@ using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class EmptyTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Empty_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Empty<int>(null));
@@ -23,7 +26,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Empty<int>(DummyScheduler.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Empty_Basic()
         {
             var scheduler = new TestScheduler();
@@ -37,7 +40,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Empty_Disposed()
         {
             var scheduler = new TestScheduler();
@@ -51,7 +54,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Empty_ObserverThrows()
         {
             var scheduler1 = new TestScheduler();
@@ -63,13 +66,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => scheduler1.Start());
         }
 
-        [Fact]
+        [TestMethod]
         public void Empty_DefaultScheduler()
         {
             Observable.Empty<int>().AssertEqual(Observable.Empty<int>(DefaultScheduler.Instance));
         }
 
-        [Fact]
+        [TestMethod]
         public void Empty_Basic_Witness1()
         {
             var scheduler = new TestScheduler();
@@ -83,7 +86,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Empty_Basic_Witness2()
         {
             var e = new ManualResetEvent(false);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ExpandTest.cs

@@ -7,14 +7,17 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ExpandTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Expand_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Expand(null, DummyFunc<int, IObservable<int>>.Instance, DummyScheduler.Instance));
@@ -24,7 +27,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.Expand(DummyObservable<int>.Instance, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Expand_Default()
         {
             var b = Observable.Return(1).Expand(x => x < 10 ? Observable.Return(x + 1) : Observable.Empty<int>())
@@ -33,7 +36,7 @@ namespace ReactiveTests.Tests
             Assert.True(b);
         }
 
-        [Fact]
+        [TestMethod]
         public void Expand_Empty()
         {
             var scheduler = new TestScheduler();
@@ -59,7 +62,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Expand_Error()
         {
             var scheduler = new TestScheduler();
@@ -87,7 +90,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Expand_Never()
         {
             var scheduler = new TestScheduler();
@@ -111,7 +114,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Expand_Basic()
         {
             var scheduler = new TestScheduler();
@@ -152,7 +155,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Expand_Throw()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FinallyTest.cs

@@ -6,14 +6,17 @@ using System;
 using System.Reactive;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FinallyTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void Finally_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -22,7 +25,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Finally(someObservable, null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_Never()
         {
             var scheduler = new TestScheduler();
@@ -38,7 +41,7 @@ namespace ReactiveTests.Tests
             Assert.True(invoked); // due to unsubscribe; see 1356
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_OnlyCalledOnce_Never()
         {
             var invokeCount = 0;
@@ -50,7 +53,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, invokeCount);
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_OnlyCalledOnce_Empty()
         {
             var invokeCount = 0;
@@ -62,7 +65,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(1, invokeCount);
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_Empty()
         {
             var scheduler = new TestScheduler();
@@ -88,7 +91,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_Return()
         {
             var scheduler = new TestScheduler();
@@ -116,7 +119,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_Throw()
         {
             var scheduler = new TestScheduler();
@@ -143,7 +146,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_DisposeOrder_Empty()
         {
             var order = "";
@@ -157,7 +160,7 @@ namespace ReactiveTests.Tests
             Assert.Equal("123", order);
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_DisposeOrder_Return()
         {
             var order = "";
@@ -171,7 +174,7 @@ namespace ReactiveTests.Tests
             Assert.Equal("123", order);
         }
 
-        [Fact]
+        [TestMethod]
         public void Finally_DisposeOrder_Never()
         {
             var order = "";

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstAsyncTest.cs

@@ -6,13 +6,14 @@ using System;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FirstAsyncTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void FirstAsync_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FirstAsync(default(IObservable<int>)));
@@ -20,7 +21,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FirstAsync(DummyObservable<int>.Instance, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_Empty()
         {
             var scheduler = new TestScheduler();
@@ -43,7 +44,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_One()
         {
             var scheduler = new TestScheduler();
@@ -68,7 +69,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_Many()
         {
             var scheduler = new TestScheduler();
@@ -94,7 +95,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_Error()
         {
             var scheduler = new TestScheduler();
@@ -119,7 +120,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_Predicate()
         {
             var scheduler = new TestScheduler();
@@ -147,7 +148,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_Predicate_None()
         {
             var scheduler = new TestScheduler();
@@ -174,7 +175,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_Predicate_Throw()
         {
             var scheduler = new TestScheduler();
@@ -200,7 +201,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstAsync_PredicateThrows()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultAsyncTest.cs

@@ -6,13 +6,14 @@ using System;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FirstOrDefaultAsyncTest : ReactiveTest
     {
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FirstOrDefaultAsync(default(IObservable<int>)));
@@ -20,7 +21,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FirstOrDefaultAsync(DummyObservable<int>.Instance, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_Empty()
         {
             var scheduler = new TestScheduler();
@@ -44,7 +45,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_One()
         {
             var scheduler = new TestScheduler();
@@ -69,7 +70,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_Many()
         {
             var scheduler = new TestScheduler();
@@ -95,7 +96,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_Error()
         {
             var scheduler = new TestScheduler();
@@ -120,7 +121,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_Predicate()
         {
             var scheduler = new TestScheduler();
@@ -150,7 +151,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_Predicate_None()
         {
             var scheduler = new TestScheduler();
@@ -180,7 +181,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_Predicate_Throw()
         {
             var scheduler = new TestScheduler();
@@ -206,7 +207,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultAsync_PredicateThrows()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultTest.cs

@@ -10,14 +10,17 @@ using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FirstOrDefaultTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefault_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FirstOrDefault(default(IObservable<int>)));
@@ -25,26 +28,26 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FirstOrDefault(DummyObservable<int>.Instance, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefault_Empty()
         {
             Assert.Equal(default, Observable.Empty<int>().FirstOrDefault());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefaultPredicate_Empty()
         {
             Assert.Equal(default, Observable.Empty<int>().FirstOrDefault(_ => true));
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefault_Return()
         {
             var value = 42;
             Assert.Equal(value, Observable.Return(value).FirstOrDefault());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefault_Throw()
         {
             var ex = new Exception();
@@ -54,7 +57,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.FirstOrDefault());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstOrDefault_Range()
         {
             var value = 42;
@@ -62,7 +65,7 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void FirstOrDefault_NoDoubleSet()
         {
             //

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstTest.cs

@@ -7,14 +7,17 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FirstTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void First_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.First(default(IObservable<int>)));
@@ -22,40 +25,40 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.First(DummyObservable<int>.Instance, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void First_Empty()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Empty<int>().First());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstPredicate_Empty()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Empty<int>().First(_ => true));
         }
 
-        [Fact]
+        [TestMethod]
         public void First_Return()
         {
             var value = 42;
             Assert.Equal(value, Observable.Return(value).First());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstPredicate_Return()
         {
             var value = 42;
             Assert.Equal(value, Observable.Return(value).First(i => i % 2 == 0));
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstPredicate_Return_NoMatch()
         {
             var value = 42;
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.Return(value).First(i => i % 2 != 0));
         }
 
-        [Fact]
+        [TestMethod]
         public void First_Throw()
         {
             var ex = new Exception();
@@ -65,7 +68,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.First());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstPredicate_Throw()
         {
             var ex = new Exception();
@@ -75,14 +78,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.First(_ => true));
         }
 
-        [Fact]
+        [TestMethod]
         public void First_Range()
         {
             var value = 42;
             Assert.Equal(value, Observable.Range(value, 10).First());
         }
 
-        [Fact]
+        [TestMethod]
         public void FirstPredicate_Range()
         {
             var value = 42;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachAsyncTest.cs

@@ -10,14 +10,17 @@ using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ForEachAsyncTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ForEachAsync(default(IObservable<int>), x => { }));
@@ -31,7 +34,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ForEachAsync(Observable.Never<int>(), default(Action<int, int>), CancellationToken.None));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Never()
         {
             var scheduler = new TestScheduler();
@@ -66,7 +69,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(TaskStatus.WaitingForActivation, task.Status);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Completed()
         {
             var scheduler = new TestScheduler();
@@ -102,7 +105,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Error()
         {
             var scheduler = new TestScheduler();
@@ -141,7 +144,7 @@ namespace ReactiveTests.Tests
             Assert.Same(exception, task.Exception.InnerException);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Throw()
         {
             var scheduler = new TestScheduler();
@@ -187,7 +190,7 @@ namespace ReactiveTests.Tests
             Assert.Same(exception, task.Exception.InnerException);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_CancelDuring()
         {
             var scheduler = new TestScheduler();
@@ -222,7 +225,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_CancelBefore()
         {
             var scheduler = new TestScheduler();
@@ -255,7 +258,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(TaskStatus.Canceled, task.Status);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_CancelAfter()
         {
             var scheduler = new TestScheduler();
@@ -292,7 +295,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(TaskStatus.RanToCompletion, task.Status);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Default()
         {
             var list = new List<int>();
@@ -300,7 +303,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Index()
         {
             var list = new List<int>();
@@ -308,7 +311,7 @@ namespace ReactiveTests.Tests
             list.AssertEqual(3 * 0, 4 * 1, 5 * 2, 6 * 3, 7 * 4);
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Default_Cancel()
         {
             var N = 10;
@@ -367,7 +370,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_Index_Cancel()
         {
             var N = 10;
@@ -426,7 +429,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_DisposeThrows1()
         {
             var cts = new CancellationTokenSource();
@@ -464,7 +467,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_DisposeThrows2()
         {
             var cts = new CancellationTokenSource();
@@ -507,8 +510,8 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact]
-        [Trait("SkipCI", "true")]
+        [TestMethod]
+        [TestCategory("SkipCI")]
         public void ForEachAsync_DisposeThrows()
         {
             //
@@ -561,7 +564,7 @@ namespace ReactiveTests.Tests
             }
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEachAsync_SubscribeThrows()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachTest.cs

@@ -7,14 +7,17 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ForEachTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void ForEach_ArgumentChecking()
         {
             var someObservable = Observable.Empty<int>();
@@ -26,7 +29,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.ForEach(someObservable, default(Action<int, int>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Empty()
         {
             var lst = new List<int>();
@@ -34,7 +37,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(Enumerable.Empty<int>()));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Index_Empty()
         {
             var lstX = new List<int>();
@@ -42,7 +45,7 @@ namespace ReactiveTests.Tests
             Assert.True(lstX.SequenceEqual(Enumerable.Empty<int>()));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Return()
         {
             var lst = new List<int>();
@@ -50,7 +53,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.SequenceEqual(new[] { 42 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Index_Return()
         {
             var lstX = new List<int>();
@@ -60,7 +63,7 @@ namespace ReactiveTests.Tests
             Assert.True(lstI.SequenceEqual(new[] { 0 }));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Throw()
         {
             var ex = new Exception();
@@ -70,7 +73,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.ForEach(x => { Assert.True(false); }));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Index_Throw()
         {
             var ex = new Exception();
@@ -80,7 +83,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.ForEach((x, i) => { Assert.True(false); }));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_SomeData()
         {
             var lstX = new List<int>();
@@ -88,7 +91,7 @@ namespace ReactiveTests.Tests
             Assert.True(lstX.SequenceEqual(Enumerable.Range(10, 10)));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Index_SomeData()
         {
             var lstX = new List<int>();
@@ -98,7 +101,7 @@ namespace ReactiveTests.Tests
             Assert.True(lstI.SequenceEqual(Enumerable.Range(0, 10)));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_OnNextThrows()
         {
             var ex = new Exception();
@@ -108,7 +111,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.ForEach(x => { throw ex; }));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForEach_Index_OnNextThrows()
         {
             var ex = new Exception();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForTest.cs

@@ -7,21 +7,22 @@ using System.Collections.Generic;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ForTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         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));
         }
 
-        [Fact]
+        [TestMethod]
         public void For_Basic()
         {
             var scheduler = new TestScheduler();
@@ -54,7 +55,7 @@ namespace ReactiveTests.Tests
             throw ex;
         }
 
-        [Fact]
+        [TestMethod]
         public void For_Error_Iterator()
         {
             var scheduler = new TestScheduler();
@@ -81,7 +82,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void For_Error_Source()
         {
             var scheduler = new TestScheduler();
@@ -95,7 +96,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void For_SelectorThrows()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForkJoinTest.cs

@@ -8,14 +8,15 @@ using System.Linq;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class ForkJoinTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_ArgumentChecking()
         {
             var someObservable = DummyObservable<int>.Instance;
@@ -27,7 +28,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => ObservableEx.ForkJoin((IEnumerable<IObservable<int>>)null));
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_EmptyEmpty()
         {
             var scheduler = new TestScheduler();
@@ -51,7 +52,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_None()
         {
             var scheduler = new TestScheduler();
@@ -62,7 +63,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_EmptyReturn()
         {
             var scheduler = new TestScheduler();
@@ -87,7 +88,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_ReturnEmpty()
         {
             var scheduler = new TestScheduler();
@@ -112,7 +113,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_ReturnReturn()
         {
             var scheduler = new TestScheduler();
@@ -139,7 +140,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_EmptyThrow()
         {
             var ex = new Exception();
@@ -166,7 +167,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_ThrowEmpty()
         {
             var ex = new Exception();
@@ -193,7 +194,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_ReturnThrow()
         {
             var ex = new Exception();
@@ -221,7 +222,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_ThrowReturn()
         {
             var ex = new Exception();
@@ -249,7 +250,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_Binary()
         {
             var scheduler = new TestScheduler();
@@ -278,7 +279,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_NaryParams()
         {
             var scheduler = new TestScheduler();
@@ -316,7 +317,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_NaryParamsEmpty()
         {
             var scheduler = new TestScheduler();
@@ -350,7 +351,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_NaryParamsEmptyBeforeEnd()
         {
             var scheduler = new TestScheduler();
@@ -384,13 +385,13 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_Nary_Immediate()
         {
             ObservableEx.ForkJoin(Observable.Return(1), Observable.Return(2)).First().SequenceEqual(new[] { 1, 2 });
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_Nary_Virtual_And_Immediate()
         {
             var scheduler = new TestScheduler();
@@ -428,7 +429,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_Nary_Immediate_And_Virtual()
         {
             var scheduler = new TestScheduler();
@@ -466,7 +467,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void ForkJoin_Nary()
         {
             var scheduler = new TestScheduler();
@@ -504,7 +505,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Bug_1302_SelectorThrows_LeftLast()
         {
             var scheduler = new TestScheduler();
@@ -536,7 +537,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Bug_1302_SelectorThrows_RightLast()
         {
             var scheduler = new TestScheduler();
@@ -568,7 +569,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Bug_1302_RightLast_NoLeft()
         {
             var scheduler = new TestScheduler();
@@ -597,7 +598,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Bug_1302_RightLast_NoRight()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncPatternTest.cs

@@ -8,11 +8,14 @@ using System.Reactive;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
 #pragma warning disable IDE0039 // Use local function
+    [TestClass]
     public class FromAsyncPatternTest : ReactiveTest
     {
         private readonly Task<int> _doneTask;
@@ -24,7 +27,7 @@ namespace ReactiveTests.Tests
             _doneTask = tcs.Task;
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern(null, iar => { }));
@@ -90,7 +93,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsyncPattern<int, int, int, int, int, int, int, int, int, int, int, int, int, int, int>((a, b, c, d, e, f, g, h, i, j, k, l, m, n, cb, o) => null, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern0()
         {
             var x = new Result();
@@ -102,7 +105,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction0()
         {
             var x = new Result();
@@ -114,7 +117,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern0_Error()
         {
             var x = new Result();
@@ -127,7 +130,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern0_ErrorBegin()
         {
             var x = new Result();
@@ -140,7 +143,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern1()
         {
             var x = new Result();
@@ -157,7 +160,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction1()
         {
             var x = new Result();
@@ -174,7 +177,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern1_Error()
         {
             var x = new Result();
@@ -187,7 +190,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern1_ErrorBegin()
         {
             var x = new Result();
@@ -200,7 +203,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern2()
         {
             var x = new Result();
@@ -218,7 +221,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction2()
         {
             var x = new Result();
@@ -236,7 +239,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern2_Error()
         {
             var x = new Result();
@@ -249,7 +252,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern2_ErrorBegin()
         {
             var x = new Result();
@@ -262,7 +265,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern3()
         {
             var x = new Result();
@@ -280,7 +283,7 @@ namespace ReactiveTests.Tests
             var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4).Materialize().ToEnumerable().ToArray();
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction3()
         {
             var x = new Result();
@@ -299,7 +302,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern3_Error()
         {
             var x = new Result();
@@ -312,7 +315,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern3_ErrorBegin()
         {
             var x = new Result();
@@ -325,7 +328,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern4()
         {
             var x = new Result();
@@ -345,7 +348,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction4()
         {
             var x = new Result();
@@ -365,7 +368,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern4_Error()
         {
             var x = new Result();
@@ -378,7 +381,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern4_ErrorBegin()
         {
             var x = new Result();
@@ -391,7 +394,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern5()
         {
             var x = new Result();
@@ -412,7 +415,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction5()
         {
             var x = new Result();
@@ -433,7 +436,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern5_Error()
         {
             var x = new Result();
@@ -446,7 +449,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern5_ErrorBegin()
         {
             var x = new Result();
@@ -459,7 +462,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern6()
         {
             var x = new Result();
@@ -481,7 +484,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction6()
         {
             var x = new Result();
@@ -503,7 +506,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern6_Error()
         {
             var x = new Result();
@@ -516,7 +519,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern6_ErrorBegin()
         {
             var x = new Result();
@@ -529,7 +532,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern7()
         {
             var x = new Result();
@@ -552,7 +555,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction7()
         {
             var x = new Result();
@@ -575,7 +578,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern7_Error()
         {
             var x = new Result();
@@ -588,7 +591,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern7_ErrorBegin()
         {
             var x = new Result();
@@ -601,7 +604,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern8()
         {
             var x = new Result();
@@ -625,7 +628,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction8()
         {
             var x = new Result();
@@ -649,7 +652,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern8_Error()
         {
             var x = new Result();
@@ -662,7 +665,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern8_ErrorBegin()
         {
             var x = new Result();
@@ -675,7 +678,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern9()
         {
             var x = new Result();
@@ -700,7 +703,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction9()
         {
             var x = new Result();
@@ -725,7 +728,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern9_Error()
         {
             var x = new Result();
@@ -738,7 +741,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern9_ErrorBegin()
         {
             var x = new Result();
@@ -751,7 +754,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern10()
         {
             var x = new Result();
@@ -777,7 +780,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction10()
         {
             var x = new Result();
@@ -803,7 +806,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern10_Error()
         {
             var x = new Result();
@@ -816,7 +819,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern10_ErrorBegin()
         {
             var x = new Result();
@@ -829,7 +832,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern11()
         {
             var x = new Result();
@@ -856,7 +859,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction11()
         {
             var x = new Result();
@@ -883,7 +886,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern11_Error()
         {
             var x = new Result();
@@ -896,7 +899,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern11_ErrorBegin()
         {
             var x = new Result();
@@ -909,7 +912,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern12()
         {
             var x = new Result();
@@ -937,7 +940,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction12()
         {
             var x = new Result();
@@ -965,7 +968,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern12_Error()
         {
             var x = new Result();
@@ -978,7 +981,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern12_ErrorBegin()
         {
             var x = new Result();
@@ -991,7 +994,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern13()
         {
             var x = new Result();
@@ -1020,7 +1023,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction13()
         {
             var x = new Result();
@@ -1049,7 +1052,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern13_Error()
         {
             var x = new Result();
@@ -1062,7 +1065,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern13_ErrorBegin()
         {
             var x = new Result();
@@ -1075,7 +1078,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern14()
         {
             var x = new Result();
@@ -1105,7 +1108,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted<int>() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPatternAction14()
         {
             var x = new Result();
@@ -1135,7 +1138,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new[] { new Unit() }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern14_Error()
         {
             var x = new Result();
@@ -1148,7 +1151,7 @@ namespace ReactiveTests.Tests
             Assert.True(res.SequenceEqual(new Notification<int>[] { Notification.CreateOnError<int>(ex) }));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsyncPattern14_ErrorBegin()
         {
             var x = new Result();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncTest.cs

@@ -10,10 +10,13 @@ using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FromAsyncTest : ReactiveTest
     {
         private readonly Task<int> _doneTask;
@@ -27,7 +30,7 @@ namespace ReactiveTests.Tests
 
         #region Func
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Func_ArgumentChecking()
         {
             var s = Scheduler.Immediate;
@@ -41,7 +44,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(ct => _doneTask, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Func_Success()
         {
             var n = 42;
@@ -60,7 +63,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Func_Throw_Synchronous()
         {
             var ex = new Exception();
@@ -73,7 +76,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Func_Throw_Asynchronous()
         {
             var ex = new Exception();
@@ -85,7 +88,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_FuncWithCancel_Success()
         {
             var n = 42;
@@ -104,7 +107,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_FuncWithCancel_Throw_Synchronous()
         {
             var ex = new Exception();
@@ -117,7 +120,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_FuncWithCancel_Throw_Asynchronous()
         {
             var ex = new Exception();
@@ -129,7 +132,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_FuncWithCancel_Cancel()
         {
             var e = new ManualResetEvent(false);
@@ -166,7 +169,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR
-        [Fact]
+        [TestMethod]
         public void FromAsync_Func_Scheduler1()
         {
             var e = new ManualResetEvent(false);
@@ -191,7 +194,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(Thread.CurrentThread.ManagedThreadId, t);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Func_Scheduler2()
         {
             var e = new ManualResetEvent(false);
@@ -221,7 +224,7 @@ namespace ReactiveTests.Tests
 
         #region Action
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Action_ArgumentChecking()
         {
             var s = Scheduler.Immediate;
@@ -235,7 +238,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromAsync(ct => (Task)_doneTask, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Action_Success()
         {
             var i = 0;
@@ -252,7 +255,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Action_Throw_Synchronous()
         {
             var ex = new Exception();
@@ -265,7 +268,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Action_Throw_Asynchronous()
         {
             var ex = new Exception();
@@ -277,7 +280,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_ActionWithCancel_Success()
         {
             var i = 0;
@@ -294,7 +297,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, i);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_ActionWithCancel_Throw_Synchronous()
         {
             var ex = new Exception();
@@ -307,7 +310,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_ActionWithCancel_Throw_Asynchronous()
         {
             var ex = new Exception();
@@ -319,7 +322,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws(ex, () => xs.Single());
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_ActionWithCancel_Cancel()
         {
             var e = new ManualResetEvent(false);
@@ -356,7 +359,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR
-        [Fact]
+        [TestMethod]
         public void FromAsync_Action_Scheduler1()
         {
             var e = new ManualResetEvent(false);
@@ -378,7 +381,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(Thread.CurrentThread.ManagedThreadId, t);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromAsync_Action_Scheduler2()
         {
             var e = new ManualResetEvent(false);

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventPatternTest.cs

@@ -13,16 +13,19 @@ using System.Reactive.Linq;
 using System.Reflection;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FromEventPatternTest : ReactiveTest
     {
 
         #region Strongly typed
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Conversion_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern(null, h => { }));
@@ -42,7 +45,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern<EventHandler, EventArgs>(h => new EventHandler(h), h => { }, h => { }, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_E2()
         {
             var scheduler = new TestScheduler();
@@ -69,7 +72,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Conversion_E4()
         {
             var scheduler = new TestScheduler();
@@ -97,7 +100,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Conversion_E5()
         {
             var scheduler = new TestScheduler();
@@ -124,7 +127,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_ConversionThrows()
         {
             var ex = new Exception();
@@ -144,7 +147,7 @@ namespace ReactiveTests.Tests
             Assert.Same(ex, err);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_E2_WithSender()
         {
             var scheduler = new TestScheduler();
@@ -171,7 +174,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_AddRemove_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern<EventArgs>(null, h => { }));
@@ -196,7 +199,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEventPattern<EventHandler, object, EventArgs>(h => { }, h => { }, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_AddRemove_E4()
         {
             var scheduler = new TestScheduler();
@@ -229,7 +232,7 @@ namespace ReactiveTests.Tests
 
         #region Instance events
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_ArgumentChecking()
         {
             ReactiveAssert.Throws</**/ArgumentNullException>(() => Observable.FromEventPattern(default(object), "foo"));
@@ -269,13 +272,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.FromEventPattern<FromEventPattern_ArgCheck, EventArgs>(new FromEventPattern_ArgCheck(), "foo"));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_InvalidVariance()
         {
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.FromEventPattern<CancelEventArgs>(new FromEventPattern_VarianceCheck(), "E1"));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_VarianceArgs()
         {
             var src = new FromEventPattern_VarianceCheck();
@@ -299,7 +302,7 @@ namespace ReactiveTests.Tests
             Assert.True(ReferenceEquals(e2, lst[1].EventArgs), "Second");
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_VarianceSender()
         {
             var src = new FromEventPattern_VarianceCheck();
@@ -323,7 +326,7 @@ namespace ReactiveTests.Tests
             Assert.True(ReferenceEquals(s2, lst[1].Sender), "Second");
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_NonGeneric()
         {
             var src = new FromEventPattern_VarianceCheck();
@@ -347,7 +350,7 @@ namespace ReactiveTests.Tests
             Assert.True(ReferenceEquals(e2, lst[1].EventArgs), "Second");
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_Throws()
         {
             //
@@ -374,7 +377,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(d.Dispose);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_E1()
         {
             var scheduler = new TestScheduler();
@@ -399,7 +402,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_E2()
         {
             var scheduler = new TestScheduler();
@@ -424,7 +427,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_E2_WithSender()
         {
             var scheduler = new TestScheduler();
@@ -449,7 +452,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_E3()
         {
             var scheduler = new TestScheduler();
@@ -475,7 +478,7 @@ namespace ReactiveTests.Tests
         }
 
 #if DESKTOPCLR && NET472
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Instance_MissingAccessors()
         {
             var asm = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("EventsTest"), System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave);
@@ -511,7 +514,7 @@ namespace ReactiveTests.Tests
 
         #region Static events
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Static_ArgumentChecking()
         {
             ReactiveAssert.Throws</**/ArgumentNullException>(() => Observable.FromEventPattern(default, "foo"));
@@ -536,7 +539,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<InvalidOperationException>(() => Observable.FromEventPattern<object, EventArgs>(typeof(FromEventPattern_ArgCheck), "foo"));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Static_E6()
         {
             var scheduler = new TestScheduler();
@@ -559,7 +562,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Static_E6_WithSender()
         {
             var scheduler = new TestScheduler();
@@ -582,7 +585,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Reflection_Static_NonGeneric_E6()
         {
             var scheduler = new TestScheduler();
@@ -612,13 +615,13 @@ namespace ReactiveTests.Tests
 
         #region Rx v2.0 behavior
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler1()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler2()
         {
             RunWithScheduler((s, add, remove) =>
@@ -629,7 +632,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler3()
         {
             RunWithScheduler((s, add, remove) =>
@@ -640,13 +643,13 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler4()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern(h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler5()
         {
             RunWithScheduler((s, add, remove) =>
@@ -657,7 +660,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler6()
         {
             RunWithScheduler((s, add, remove) =>
@@ -668,19 +671,19 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler7()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<EventHandler<MyEventArgs>, MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler8()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<EventHandler<MyEventArgs>, MyEventArgs>(h => h, h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler9()
         {
             RunWithScheduler((s, add, remove) =>
@@ -691,7 +694,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler10()
         {
             RunWithScheduler((s, add, remove) =>
@@ -702,7 +705,7 @@ namespace ReactiveTests.Tests
             });
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEventPattern_Scheduler11()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEventPattern<EventHandler<MyEventArgs>, object, MyEventArgs>(h => { add(); }, h => { remove(); }, s));

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventTest.cs

@@ -9,14 +9,17 @@ using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Threading;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class FromEventTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEvent<Action<int>, int>(default, h => { }, h => { }));
@@ -50,7 +53,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.FromEvent(h => { }, h => { }, default));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_Action()
         {
             var fe = new FromEvent();
@@ -72,7 +75,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2, n);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_ActionOfInt()
         {
             var fe = new FromEvent();
@@ -94,7 +97,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2 + 3, n);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_ActionOfInt_SpecifiedExplicitly()
         {
             var fe = new FromEvent();
@@ -116,7 +119,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2 + 3, n);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_ActionOfInt_SpecifiedExplicitly_TrivialConversion()
         {
             var fe = new FromEvent();
@@ -138,7 +141,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(2 + 3, n);
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_MyAction()
         {
             var fe = new FromEvent();
@@ -162,7 +165,7 @@ namespace ReactiveTests.Tests
 
         #region Rx v2.0 behavior
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_ImplicitPublish()
         {
             var src = new MyEventSource();
@@ -238,7 +241,7 @@ namespace ReactiveTests.Tests
             Assert.True(thd.SequenceEqual(new[] { 44, 45 }));
         }
 #if !NO_THREAD
-        [Fact]
+        [TestMethod]
         public void FromEvent_SynchronizationContext()
         {
             var beforeSubscribeNull = false;
@@ -336,25 +339,25 @@ namespace ReactiveTests.Tests
         }
 #endif
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_Scheduler1()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent<MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_Scheduler2()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent(h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_Scheduler3()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent<Action<MyEventArgs>, MyEventArgs>(h => { add(); }, h => { remove(); }, s));
         }
 
-        [Fact]
+        [TestMethod]
         public void FromEvent_Scheduler4()
         {
             RunWithScheduler((s, add, remove) => Observable.FromEvent<Action, MyEventArgs>(h => () => { }, h => { add(); }, h => { remove(); }, s));

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GenerateTest.cs

@@ -12,15 +12,18 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class GenerateTest : ReactiveTest
     {
         #region + Non-timed +
 
-        [Fact]
+        [TestMethod]
         public void Generate_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, (IScheduler)null));
@@ -30,7 +33,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyScheduler.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_Finite()
         {
             var scheduler = new TestScheduler();
@@ -48,7 +51,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_Throw_Condition()
         {
             var scheduler = new TestScheduler();
@@ -64,7 +67,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_Throw_ResultSelector()
         {
             var scheduler = new TestScheduler();
@@ -80,7 +83,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_Throw_Iterate()
         {
             var scheduler = new TestScheduler();
@@ -97,7 +100,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -113,7 +116,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DefaultScheduler_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, null, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance));
@@ -122,14 +125,14 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DefaultScheduler()
         {
             Observable.Generate(0, x => x < 10, x => x + 1, x => x).AssertEqual(Observable.Generate(0, x => x < 10, x => x + 1, x => x, DefaultScheduler.Instance));
         }
 
 #if !NO_PERF
-        [Fact]
+        [TestMethod]
         public void Generate_LongRunning1()
         {
             var start = default(ManualResetEvent);
@@ -148,7 +151,7 @@ namespace ReactiveTests.Tests
             Assert.True(done);
         }
 
-        [Fact]
+        [TestMethod]
         [MethodImpl(MethodImplOptions.NoOptimization)]
         public void Generate_LongRunning2()
         {
@@ -174,7 +177,7 @@ namespace ReactiveTests.Tests
             Assert.True(lst.Take(100).SequenceEqual(Enumerable.Range(0, 100)));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_LongRunning_Throw()
         {
             var start = default(ManualResetEvent);
@@ -201,7 +204,7 @@ namespace ReactiveTests.Tests
 
         #region + Timed +
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, TimeSpan>.Instance, null));
@@ -212,7 +215,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, TimeSpan>.Instance, DummyScheduler.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_Finite()
         {
             var scheduler = new TestScheduler();
@@ -230,7 +233,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_Throw_Condition()
         {
             var scheduler = new TestScheduler();
@@ -246,7 +249,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_Throw_ResultSelector()
         {
             var scheduler = new TestScheduler();
@@ -262,7 +265,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_Throw_Iterate()
         {
             var scheduler = new TestScheduler();
@@ -279,7 +282,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_Throw_TimeSelector()
         {
             var scheduler = new TestScheduler();
@@ -295,7 +298,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -312,7 +315,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_DefaultScheduler_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, null, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, TimeSpan>.Instance));
@@ -322,13 +325,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, TimeSpan>.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_DefaultScheduler()
         {
             Observable.Generate(0, x => x < 10, x => x + 1, x => x, x => TimeSpan.FromMilliseconds(x)).AssertEqual(Observable.Generate(0, x => x < 10, x => x + 1, x => x, x => TimeSpan.FromMilliseconds(x), DefaultScheduler.Instance));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, DateTimeOffset>.Instance, null));
@@ -339,7 +342,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, DateTimeOffset>.Instance, DummyScheduler.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_Finite()
         {
             var scheduler = new TestScheduler();
@@ -357,7 +360,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_Throw_Condition()
         {
             var scheduler = new TestScheduler();
@@ -373,7 +376,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_Throw_ResultSelector()
         {
             var scheduler = new TestScheduler();
@@ -389,7 +392,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_Throw_Iterate()
         {
             var scheduler = new TestScheduler();
@@ -406,7 +409,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_Throw_TimeSelector()
         {
             var scheduler = new TestScheduler();
@@ -422,7 +425,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -439,7 +442,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_DefaultScheduler_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, null, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, DateTimeOffset>.Instance));
@@ -449,13 +452,13 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.Generate(0, DummyFunc<int, bool>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, DummyFunc<int, DateTimeOffset>.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_DefaultScheduler()
         {
             Observable.Generate(0, x => x < 10, x => x + 1, x => x, x => DateTimeOffset.Now.AddMilliseconds(x)).AssertEqual(Observable.Generate(0, x => x < 10, x => x + 1, x => x, x => DateTimeOffset.Now.AddMilliseconds(x), DefaultScheduler.Instance));
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_TimeSpan_DisposeLater()
         {
             var count = 0;
@@ -471,7 +474,7 @@ namespace ReactiveTests.Tests
             d.Dispose();
         }
 
-        [Fact]
+        [TestMethod]
         public void Generate_DateTimeOffset_DisposeLater()
         {
             var count = 0;

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GetEnumeratorTest.cs

@@ -9,20 +9,23 @@ using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using Microsoft.Reactive.Testing;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class GetEnumeratorTest : ReactiveTest
     {
 
-        [Fact]
+        [TestMethod]
         public void GetEnumerator_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetEnumerator(default(IObservable<int>)));
         }
 
-        [Fact]
+        [TestMethod]
         public void GetEnumerator_Regular1()
         {
             var scheduler = new TestScheduler();
@@ -74,7 +77,7 @@ namespace ReactiveTests.Tests
             Assert.True(vals[3].Item1 == 230 && vals[3].Item2 == 7);
         }
 
-        [Fact]
+        [TestMethod]
         public void GetEnumerator_Regular2()
         {
             var scheduler = new TestScheduler();
@@ -126,7 +129,7 @@ namespace ReactiveTests.Tests
             Assert.True(vals[3].Item1 == 180 && vals[3].Item2 == 7);
         }
 
-        [Fact]
+        [TestMethod]
         public void GetEnumerator_Dispose()
         {
             var scheduler = new TestScheduler();

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByTest.cs

@@ -10,15 +10,18 @@ using System.Reactive.Linq;
 using System.Text;
 using Microsoft.Reactive.Testing;
 using ReactiveTests.Dummies;
-using Xunit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Assert = Xunit.Assert;
 
 namespace ReactiveTests.Tests
 {
+    [TestClass]
     public class GroupByTest : ReactiveTest
     {
         #region + GroupBy +
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, EqualityComparer<int>.Default));
@@ -28,7 +31,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, EqualityComparer<int>.Default).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_KeyEle_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance));
@@ -37,7 +40,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_KeyComparer_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, EqualityComparer<int>.Default));
@@ -46,7 +49,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, EqualityComparer<int>.Default).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Key_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance));
@@ -54,7 +57,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance).Subscribe(null));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_WithKeyComparer()
         {
             var scheduler = new TestScheduler();
@@ -108,7 +111,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(12, keyInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_Complete()
         {
             var scheduler = new TestScheduler();
@@ -172,7 +175,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(12, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_Error()
         {
             var scheduler = new TestScheduler();
@@ -237,7 +240,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(12, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -298,7 +301,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(5, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_KeyThrow()
         {
             var scheduler = new TestScheduler();
@@ -368,7 +371,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(9, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_EleThrow()
         {
             var scheduler = new TestScheduler();
@@ -438,7 +441,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(10, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_ComparerEqualsThrow()
         {
             var scheduler = new TestScheduler();
@@ -500,7 +503,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(3, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_ComparerGetHashCodeThrow()
         {
             var scheduler = new TestScheduler();
@@ -564,7 +567,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(7, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Complete()
         {
             var scheduler = new TestScheduler();
@@ -648,7 +651,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Complete_All()
         {
             var scheduler = new TestScheduler();
@@ -738,7 +741,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Error()
         {
             var scheduler = new TestScheduler();
@@ -824,7 +827,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -905,7 +908,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_KeyThrow()
         {
             var scheduler = new TestScheduler();
@@ -997,7 +1000,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_EleThrow()
         {
             var scheduler = new TestScheduler();
@@ -1093,7 +1096,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Comparer_EqualsThrow()
         {
             var scheduler = new TestScheduler();
@@ -1178,7 +1181,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Comparer_GetHashCodeThrow()
         {
             var scheduler = new TestScheduler();
@@ -1263,7 +1266,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Outer_Independence()
         {
             var scheduler = new TestScheduler();
@@ -1350,7 +1353,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Independence()
         {
             var scheduler = new TestScheduler();
@@ -1441,7 +1444,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Multiple_Independence()
         {
             var scheduler = new TestScheduler();
@@ -1528,7 +1531,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Escape_Complete()
         {
             var scheduler = new TestScheduler();
@@ -1574,7 +1577,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Escape_Error()
         {
             var scheduler = new TestScheduler();
@@ -1622,7 +1625,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Inner_Escape_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -1668,7 +1671,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_NullKeys_Simple()
         {
             var scheduler = new TestScheduler();
@@ -1696,7 +1699,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_NullKeys_Error()
         {
             var scheduler = new TestScheduler();
@@ -1748,7 +1751,7 @@ namespace ReactiveTests.Tests
 
         private const int _groupByCapacity = 1024;
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, _groupByCapacity, EqualityComparer<int>.Default));
@@ -1760,7 +1763,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, -1, EqualityComparer<int>.Default));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_KeyEle_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, _groupByCapacity));
@@ -1771,7 +1774,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, DummyFunc<int, int>.Instance, -1));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_KeyComparer_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, _groupByCapacity, EqualityComparer<int>.Default));
@@ -1782,7 +1785,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, -1, EqualityComparer<int>.Default));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Key_ArgumentChecking()
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => ((IObservable<int>)null).GroupBy(DummyFunc<int, int>.Instance, _groupByCapacity));
@@ -1792,7 +1795,7 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => DummyObservable<int>.Instance.GroupBy(DummyFunc<int, int>.Instance, -1));
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_WithKeyComparer()
         {
             var scheduler = new TestScheduler();
@@ -1846,7 +1849,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(12, keyInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_Complete()
         {
             var scheduler = new TestScheduler();
@@ -1911,7 +1914,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(12, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_Error()
         {
             var scheduler = new TestScheduler();
@@ -1977,7 +1980,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(12, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -2038,7 +2041,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(5, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_KeyThrow()
         {
             var scheduler = new TestScheduler();
@@ -2109,7 +2112,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(9, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_EleThrow()
         {
             var scheduler = new TestScheduler();
@@ -2180,7 +2183,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(10, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_ComparerEqualsThrow()
         {
             var scheduler = new TestScheduler();
@@ -2243,7 +2246,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(3, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_ComparerGetHashCodeThrow()
         {
             var scheduler = new TestScheduler();
@@ -2308,7 +2311,7 @@ namespace ReactiveTests.Tests
             Assert.Equal(7, eleInvoked);
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Complete()
         {
             var scheduler = new TestScheduler();
@@ -2392,7 +2395,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Complete_All()
         {
             var scheduler = new TestScheduler();
@@ -2482,7 +2485,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Error()
         {
             var scheduler = new TestScheduler();
@@ -2568,7 +2571,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -2649,7 +2652,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_KeyThrow()
         {
             var scheduler = new TestScheduler();
@@ -2741,7 +2744,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_EleThrow()
         {
             var scheduler = new TestScheduler();
@@ -2837,7 +2840,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Comparer_EqualsThrow()
         {
             var scheduler = new TestScheduler();
@@ -2922,7 +2925,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Comparer_GetHashCodeThrow()
         {
             var scheduler = new TestScheduler();
@@ -3007,7 +3010,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Outer_Independence()
         {
             var scheduler = new TestScheduler();
@@ -3094,7 +3097,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Independence()
         {
             var scheduler = new TestScheduler();
@@ -3185,7 +3188,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Multiple_Independence()
         {
             var scheduler = new TestScheduler();
@@ -3272,7 +3275,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Escape_Complete()
         {
             var scheduler = new TestScheduler();
@@ -3318,7 +3321,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Escape_Error()
         {
             var scheduler = new TestScheduler();
@@ -3366,7 +3369,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_Inner_Escape_Dispose()
         {
             var scheduler = new TestScheduler();
@@ -3412,7 +3415,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_NullKeys_Simple()
         {
             var scheduler = new TestScheduler();
@@ -3440,7 +3443,7 @@ namespace ReactiveTests.Tests
             );
         }
 
-        [Fact]
+        [TestMethod]
         public void GroupBy_Capacity_NullKeys_Error()
         {
             var scheduler = new TestScheduler();