diff --git a/AsyncRx.NET/Directory.build.props b/AsyncRx.NET/Directory.build.props index d7701965fb..49bfd26987 100644 --- a/AsyncRx.NET/Directory.build.props +++ b/AsyncRx.NET/Directory.build.props @@ -31,7 +31,7 @@ - + diff --git a/Ix.NET/Source/Directory.Build.props b/Ix.NET/Source/Directory.Build.props index e0146a53a7..992f96c76f 100644 --- a/Ix.NET/Source/Directory.Build.props +++ b/Ix.NET/Source/Directory.Build.props @@ -34,7 +34,7 @@ - + diff --git a/Rx.NET/Integration/LinuxTests/LinuxTests.csproj b/Rx.NET/Integration/LinuxTests/LinuxTests.csproj index a898655ed6..237b4f433d 100644 --- a/Rx.NET/Integration/LinuxTests/LinuxTests.csproj +++ b/Rx.NET/Integration/LinuxTests/LinuxTests.csproj @@ -24,11 +24,12 @@ - - - - - - + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Integration/WindowsDesktopTests/WindowsDesktopTests.csproj b/Rx.NET/Integration/WindowsDesktopTests/WindowsDesktopTests.csproj index 60e8782a80..dc511dfec3 100644 --- a/Rx.NET/Integration/WindowsDesktopTests/WindowsDesktopTests.csproj +++ b/Rx.NET/Integration/WindowsDesktopTests/WindowsDesktopTests.csproj @@ -23,11 +23,12 @@ - - - - - - + + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/CodeCoverage.runsettings b/Rx.NET/Source/CodeCoverage.runsettings index ae69d48664..92350aec57 100644 --- a/Rx.NET/Source/CodeCoverage.runsettings +++ b/Rx.NET/Source/CodeCoverage.runsettings @@ -13,4 +13,7 @@ + + 120000 + diff --git a/Rx.NET/Source/Directory.build.props b/Rx.NET/Source/Directory.build.props index 2e16b5d1c9..8bc43042c6 100644 --- a/Rx.NET/Source/Directory.build.props +++ b/Rx.NET/Source/Directory.build.props @@ -36,7 +36,7 @@ - + diff --git a/Rx.NET/Source/src/Microsoft.Reactive.Testing/IAssertionException.cs b/Rx.NET/Source/src/Microsoft.Reactive.Testing/IAssertionException.cs new file mode 100644 index 0000000000..be5f6f643a --- /dev/null +++ b/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 +{ + /// + /// Marker interface required by xUnit. + /// + /// + /// + /// The xunit.assert.source 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. + /// + /// + /// We think this might be a bug: https://github.com/xunit/xunit/issues/2703 + /// + /// + /// 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 public), and this file + /// supplies an equivalent but internal definition. + /// + /// + internal interface IAssertionException + { + } +} diff --git a/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj b/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj index f735fad7db..ca10b35ddb 100644 --- a/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj +++ b/Rx.NET/Source/src/Microsoft.Reactive.Testing/Microsoft.Reactive.Testing.csproj @@ -8,12 +8,19 @@ Rx;Reactive;Extensions;Observable;LINQ;Events Reactive Extensions (Rx) for .NET - Testing Library - $(NoWarn);CA1305;CA1307;CA1032;CA1064;CA1822;CA1812 + $(NoWarn);IDE0054;IDE0066;CA1305;CA1307;CA1032;CA1064;CA1822;CA1812;CA1823 - + + + + + + \ No newline at end of file diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs index 0cb5836964..54ddca5e03 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.verified.cs +++ b/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 @@ public override int GetHashCode() { } public static bool operator !=(System.Reactive.EventPattern first, System.Reactive.EventPattern second) { } public static bool operator ==(System.Reactive.EventPattern first, System.Reactive.EventPattern 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 @@ public interface IQbservableProvider System.Reactive.Linq.IQbservable CreateQuery(System.Linq.Expressions.Expression expression); } public interface IQbservable : System.IObservable, 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 @@ public static System.IObservable Aggregate(this System.IObserv public static System.IObservable Aggregate(this System.IObservable source, TAccumulate seed, System.Func accumulator) { } public static System.IObservable Aggregate(this System.IObservable source, TAccumulate seed, System.Func accumulator, System.Func resultSelector) { } public static System.IObservable All(this System.IObservable source, System.Func predicate) { } - public static System.IObservable Amb(params System.IObservable<>[] sources) { } + public static System.IObservable Amb(params System.IObservable[] sources) { } public static System.IObservable Amb(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable Amb(this System.IObservable first, System.IObservable second) { } public static System.Reactive.Joins.Pattern And(this System.IObservable left, System.IObservable right) { } @@ -910,7 +910,7 @@ public static System.IObservable Case(System.Func Case(System.Func selector, System.Collections.Generic.IDictionary> sources, System.Reactive.Concurrency.IScheduler scheduler) where TValue : notnull { } public static System.IObservable Cast(this System.IObservable source) { } - public static System.IObservable Catch(params System.IObservable<>[] sources) { } + public static System.IObservable Catch(params System.IObservable[] sources) { } public static System.IObservable Catch(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable Catch(this System.IObservable first, System.IObservable second) { } public static System.IObservable Catch(this System.IObservable source, System.Func> handler) @@ -918,7 +918,7 @@ public static System.IObservable Catch(this System public static System.Collections.Generic.IEnumerable> Chunkify(this System.IObservable source) { } public static System.Collections.Generic.IEnumerable Collect(this System.IObservable source, System.Func newCollector, System.Func merge) { } public static System.Collections.Generic.IEnumerable Collect(this System.IObservable source, System.Func getInitialCollector, System.Func merge, System.Func getNewCollector) { } - public static System.IObservable> CombineLatest(params System.IObservable<>[] sources) { } + public static System.IObservable> CombineLatest(params System.IObservable[] sources) { } public static System.IObservable> CombineLatest(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable CombineLatest(this System.Collections.Generic.IEnumerable> sources, System.Func, TResult> resultSelector) { } public static System.IObservable CombineLatest(this System.IObservable first, System.IObservable second, System.Func resultSelector) { } @@ -969,7 +969,7 @@ public static System.IObservable CombineLatest source15, System.IObservable source16, System.Func resultSelector) { } - public static System.IObservable Concat(params System.IObservable<>[] sources) { } + public static System.IObservable Concat(params System.IObservable[] sources) { } public static System.IObservable Concat(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable Concat(this System.IObservable> sources) { } public static System.IObservable Concat(this System.IObservable> sources) { } @@ -1222,11 +1222,11 @@ public static System.IObservable Max(this System.IObs public static System.IObservable Max(this System.IObservable source, System.Func selector, System.Collections.Generic.IComparer comparer) { } public static System.IObservable> MaxBy(this System.IObservable source, System.Func keySelector) { } public static System.IObservable> MaxBy(this System.IObservable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } - public static System.IObservable Merge(params System.IObservable<>[] sources) { } + public static System.IObservable Merge(params System.IObservable[] sources) { } public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable Merge(this System.IObservable> sources) { } public static System.IObservable Merge(this System.IObservable> sources) { } - public static System.IObservable Merge(System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable<>[] sources) { } + public static System.IObservable Merge(System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable[] sources) { } public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources, int maxConcurrent) { } public static System.IObservable Merge(this System.Collections.Generic.IEnumerable> sources, System.Reactive.Concurrency.IScheduler scheduler) { } public static System.IObservable Merge(this System.IObservable> sources, int maxConcurrent) { } @@ -1268,7 +1268,7 @@ public static System.Collections.Generic.IEnumerable Next(this public static System.IObservable ObserveOn(this System.IObservable source, System.Reactive.Concurrency.IScheduler scheduler) { } public static System.IObservable ObserveOn(this System.IObservable source, System.Threading.SynchronizationContext context) { } public static System.IObservable OfType(this System.IObservable source) { } - public static System.IObservable OnErrorResumeNext(params System.IObservable<>[] sources) { } + public static System.IObservable OnErrorResumeNext(params System.IObservable[] sources) { } public static System.IObservable OnErrorResumeNext(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable OnErrorResumeNext(this System.IObservable first, System.IObservable second) { } public static System.IObservable Prepend(this System.IObservable source, TSource value) { } @@ -1559,7 +1559,7 @@ public static System.IObservable Using(System.Func< public static System.IObservable Using(System.Func> resourceFactoryAsync, System.Func>> observableFactoryAsync) where TResource : System.IDisposable { } public static TSource Wait(this System.IObservable source) { } - public static System.IObservable When(params System.Reactive.Joins.Plan<>[] plans) { } + public static System.IObservable When(params System.Reactive.Joins.Plan[] plans) { } public static System.IObservable When(this System.Collections.Generic.IEnumerable> plans) { } public static System.IObservable Where(this System.IObservable source, System.Func predicate) { } public static System.IObservable Where(this System.IObservable source, System.Func predicate) { } @@ -1576,7 +1576,7 @@ public static System.IObservable While(System.Func condi public static System.IObservable> Window(this System.IObservable source, System.IObservable windowBoundaries) { } public static System.IObservable> Window(this System.IObservable source, System.IObservable windowOpenings, System.Func> windowClosingSelector) { } public static System.IObservable WithLatestFrom(this System.IObservable first, System.IObservable second, System.Func resultSelector) { } - public static System.IObservable> Zip(params System.IObservable<>[] sources) { } + public static System.IObservable> Zip(params System.IObservable[] sources) { } public static System.IObservable> Zip(this System.Collections.Generic.IEnumerable> sources) { } public static System.IObservable Zip(this System.Collections.Generic.IEnumerable> sources, System.Func, TResult> resultSelector) { } public static System.IObservable Zip(this System.IObservable first, System.Collections.Generic.IEnumerable second, System.Func resultSelector) { } @@ -1690,7 +1690,7 @@ public static System.IObservable Expand(this System.IObservabl [System.Reactive.Experimental] public static System.IObservable Expand(this System.IObservable source, System.Func> selector, System.Reactive.Concurrency.IScheduler scheduler) { } [System.Reactive.Experimental] - public static System.IObservable ForkJoin(params System.IObservable<>[] sources) { } + public static System.IObservable ForkJoin(params System.IObservable[] sources) { } [System.Reactive.Experimental] public static System.IObservable ForkJoin(this System.Collections.Generic.IEnumerable> sources) { } [System.Reactive.Experimental] @@ -1771,7 +1771,7 @@ public static System.Reactive.Linq.IQbservable Aggregate Aggregate(this System.Reactive.Linq.IQbservable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator, System.Linq.Expressions.Expression> resultSelector) { } public static System.Reactive.Linq.IQbservable All(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable Amb(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } public static System.Reactive.Joins.QueryablePattern And(this System.Reactive.Linq.IQbservable left, System.IObservable right) { } public static System.Reactive.Linq.IQbservable Any(this System.Reactive.Linq.IQbservable source) { } @@ -1820,7 +1820,7 @@ public static System.Reactive.Linq.IQbservable Case(th where TValue : notnull { } public static System.Reactive.Linq.IQbservable Cast(this System.Reactive.Linq.IQbservable source) { } public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } public static System.Reactive.Linq.IQbservable Catch(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression>> handler) where TException : System.Exception { } @@ -1828,7 +1828,7 @@ public static System.Reactive.Linq.IQbservable Catch Collect(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> newCollector, System.Linq.Expressions.Expression> merge) { } public static System.Linq.IQueryable Collect(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> getInitialCollector, System.Linq.Expressions.Expression> merge, System.Linq.Expressions.Expression> getNewCollector) { } public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable> CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, System.Linq.Expressions.Expression, TResult>> resultSelector) { } public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } public static System.Reactive.Linq.IQbservable CombineLatest(this System.Reactive.Linq.IQbservable source1, System.IObservable source2, System.IObservable source3, System.Linq.Expressions.Expression> resultSelector) { } @@ -1881,7 +1881,7 @@ public static System.Reactive.Linq.IQbservable CombineLatest Concat(this System.Reactive.Linq.IQbservable> sources) { } public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservable> sources) { } public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable Concat(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } public static System.Reactive.Linq.IQbservable Contains(this System.Reactive.Linq.IQbservable source, TSource value) { } public static System.Reactive.Linq.IQbservable Contains(this System.Reactive.Linq.IQbservable source, TSource value, System.Collections.Generic.IEqualityComparer comparer) { } @@ -2073,12 +2073,12 @@ public static System.Reactive.Linq.IQbservable Max(th public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable> sources) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable> sources) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable> sources, int maxConcurrent) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, int maxConcurrent) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, System.Reactive.Concurrency.IScheduler scheduler) { } - public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Reactive.Concurrency.IScheduler scheduler, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Reactive.Concurrency.IScheduler scheduler) { } public static System.Reactive.Linq.IQbservable Merge(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, int maxConcurrent, System.Reactive.Concurrency.IScheduler scheduler) { } public static System.Reactive.Linq.IQbservable Min(this System.Reactive.Linq.IQbservable source) { } @@ -2116,7 +2116,7 @@ public static System.Reactive.Linq.IQbservable ObserveOn(this public static System.Reactive.Linq.IQbservable ObserveOn(this System.Reactive.Linq.IQbservable source, System.Threading.SynchronizationContext context) { } public static System.Reactive.Linq.IQbservable OfType(this System.Reactive.Linq.IQbservable source) { } public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable OnErrorResumeNext(this System.Reactive.Linq.IQbservable first, System.IObservable second) { } public static System.Reactive.Linq.IQbservable Prepend(this System.Reactive.Linq.IQbservable source, TSource value) { } public static System.Reactive.Linq.IQbservable Prepend(this System.Reactive.Linq.IQbservable source, TSource value, System.Reactive.Concurrency.IScheduler scheduler) { } @@ -2380,7 +2380,7 @@ public static System.Reactive.Linq.IQbservable Using Using(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression>> resourceFactoryAsync, System.Linq.Expressions.Expression>>> observableFactoryAsync) where TResource : System.IDisposable { } public static System.Reactive.Linq.IQbservable When(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> plans) { } - public static System.Reactive.Linq.IQbservable When(this System.Reactive.Linq.IQbservableProvider provider, params System.Reactive.Joins.QueryablePlan<>[] plans) { } + public static System.Reactive.Linq.IQbservable When(this System.Reactive.Linq.IQbservableProvider provider, params System.Reactive.Joins.QueryablePlan[] plans) { } public static System.Reactive.Linq.IQbservable Where(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } public static System.Reactive.Linq.IQbservable Where(this System.Reactive.Linq.IQbservable source, System.Linq.Expressions.Expression> predicate) { } public static System.Reactive.Linq.IQbservable While(this System.Reactive.Linq.IQbservableProvider provider, System.Linq.Expressions.Expression> condition, System.IObservable source) { } @@ -2397,7 +2397,7 @@ public static System.Reactive.Linq.IQbservable While(this Syst public static System.Reactive.Linq.IQbservable> Window(this System.Reactive.Linq.IQbservable source, System.IObservable windowOpenings, System.Linq.Expressions.Expression>> windowClosingSelector) { } public static System.Reactive.Linq.IQbservable WithLatestFrom(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } - public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable> Zip(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources, System.Linq.Expressions.Expression, TResult>> resultSelector) { } public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable first, System.Collections.Generic.IEnumerable second, System.Linq.Expressions.Expression> resultSelector) { } public static System.Reactive.Linq.IQbservable Zip(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } @@ -2692,7 +2692,7 @@ public static System.Reactive.Linq.IQbservable Expand(this Sys [System.Reactive.Experimental] public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservableProvider provider, System.Collections.Generic.IEnumerable> sources) { } [System.Reactive.Experimental] - public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable<>[] sources) { } + public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservableProvider provider, params System.IObservable[] sources) { } [System.Reactive.Experimental] public static System.Reactive.Linq.IQbservable ForkJoin(this System.Reactive.Linq.IQbservable first, System.IObservable second, System.Linq.Expressions.Expression> resultSelector) { } [System.Reactive.Experimental] @@ -3152,4 +3152,4 @@ public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } public static System.Runtime.CompilerServices.TaskObservableMethodBuilder Create() { } } -} \ No newline at end of file +} diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs index af438329fd..25afbecf8d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Testing.verified.cs +++ b/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 @@ public class TestScheduler : System.Reactive.Concurrency.VirtualTimeScheduler CreateColdObservable(params Microsoft.Reactive.Testing.Recorded<>[] messages) { } - public Microsoft.Reactive.Testing.ITestableObservable CreateHotObservable(params Microsoft.Reactive.Testing.Recorded<>[] messages) { } + public Microsoft.Reactive.Testing.ITestableObservable CreateColdObservable(params Microsoft.Reactive.Testing.Recorded>[] messages) { } + public Microsoft.Reactive.Testing.ITestableObservable CreateHotObservable(params Microsoft.Reactive.Testing.Recorded>[] messages) { } public Microsoft.Reactive.Testing.ITestableObserver CreateObserver() { } public override System.IDisposable ScheduleAbsolute(TState state, long dueTime, System.Func action) { } public Microsoft.Reactive.Testing.ITestableObserver Start(System.Func> create) { } @@ -98,4 +98,4 @@ public Microsoft.Reactive.Testing.ITestableObserver Start(System.Func 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) diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj index d20382a7bb..ea33798e35 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj +++ b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj @@ -25,12 +25,12 @@ - - - - - - + + + + + + diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml index 1d1edeea0a..5bee72e388 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml +++ b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml @@ -1,7 +1,6 @@ - - + diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml.cs b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml.cs index 1134399693..c8188b60b6 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/App.xaml.cs +++ b/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() + /// + /// 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(). + /// + public App() + { + this.InitializeComponent(); + this.Suspending += OnSuspending; + } + + /// + /// 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. + /// + /// Details about the launch request and process. + 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); + } + + /// + /// Invoked when Navigation to a certain page fails + /// + /// The Frame which failed navigation + /// Details about the navigation failure + void OnNavigationFailed(object sender, NavigationFailedEventArgs e) + { + throw new Exception("Failed to load Page " + e.SourcePageType.FullName); + } + + /// + /// 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. + /// + /// The source of the suspend request. + /// Details about the suspend request. + 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(); } } } diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj index 958a2f075b..fa3683eac9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj +++ b/Rx.NET/Source/tests/Tests.System.Reactive.Uwp.DeviceRunner/Tests.System.Reactive.Uwp.DeviceRunner.csproj @@ -25,7 +25,7 @@ true bin\x86\Debug\ - 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 + 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 ;2008;0618 full x86 @@ -35,7 +35,7 @@ bin\x86\Release\ - 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 + 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 true ;2008;0618 pdbonly @@ -94,10 +94,11 @@ $(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 + + PackageReference + - - - + @@ -112,6 +113,7 @@ %(RecursiveDir)%(Filename)%(Extension) + @@ -134,6 +136,12 @@ + + + + + + MSBuild:Compile diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Stress/Core/Schedulers/EventLoop.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Stress/Core/Schedulers/EventLoop.cs index 52b9ce0cb3..e2cff12dcd 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Stress/Core/Schedulers/EventLoop.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Stress/Core/Schedulers/EventLoop.cs @@ -11,7 +11,7 @@ using System.Reflection; using System.Threading; using System.Threading.Tasks; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Stress.Schedulers { diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj b/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj index c4e6ca65ce..65eb48bada 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests.System.Reactive.csproj @@ -1,10 +1,11 @@  + net472;net6.0;net7.0;net6.0-windows10.0.19041 $(NoWarn);CS0618 - + true true @@ -16,9 +17,21 @@ - - - + + + + + diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Aliases.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Aliases.cs index 07cde10a85..0d7ee5285c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Aliases.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Aliases.cs @@ -6,14 +6,17 @@ 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(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/AnonymousTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/AnonymousTest.cs index 4d6b391787..a849a8684d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/AnonymousTest.cs +++ b/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(() => new AnonymousObservable(null)); } - [Fact] + [TestMethod] public void AnonymousObserver_ArgumentChecking() { ReactiveAssert.Throws(() => new AnonymousObserver(default)); @@ -34,7 +34,7 @@ public void AnonymousObserver_ArgumentChecking() ReactiveAssert.Throws(() => new AnonymousObserver(x => { }, ex => { }, default)); } - [Fact] + [TestMethod] public void AnonymousObserver_Error_Null() { var observer = new AnonymousObserver(_ => { }, e => { }, () => { }); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ArgumentValidationTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ArgumentValidationTest.cs index ccb8343624..7279689f5c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ArgumentValidationTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ArgumentValidationTest.cs @@ -14,7 +14,7 @@ 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. /// + [TestClass] public class ArgumentValidationTest { #region + Default values for the generic types + @@ -81,7 +82,7 @@ static ArgumentValidationTest() { "IEnumerable`1[IObservable`1[Int32]]", new[] { Observable.Return(1) } }, - { "SynchronizationContext", SynchronizationContext.Current }, + { "SynchronizationContext", SynchronizationContext.Current ?? new SynchronizationContext() }, { "IEqualityComparer`1[Int32]", EqualityComparer.Default }, @@ -269,13 +270,13 @@ static ArgumentValidationTest() #endregion - [Fact] + [TestMethod] public void Verify_Observable() { VerifyClass(typeof(Observable)); } - [Fact] + [TestMethod] public void Verify_ObservableEx() { VerifyClass(typeof(ObservableEx)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/AsyncLockTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/AsyncLockTest.cs index d5f3011b7a..abbd37af9a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/AsyncLockTest.cs +++ b/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(() => asyncLock.Wait(null)); } - [Fact] + [TestMethod] public void Wait_Graceful() { var ok = false; @@ -26,7 +28,7 @@ public void Wait_Graceful() Assert.True(ok); } - [Fact] + [TestMethod] public void Wait_Fail() { var l = new AsyncLock(); @@ -46,7 +48,7 @@ public void Wait_Fail() l.Wait(() => { Assert.True(false); }); } - [Fact] + [TestMethod] public void Wait_QueuesWork() { var l = new AsyncLock(); @@ -57,7 +59,7 @@ public void Wait_QueuesWork() Assert.True(l2); } - [Fact] + [TestMethod] public void Dispose() { var l = new AsyncLock(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ConcurrencyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ConcurrencyTest.cs index 4ce5e65531..59d731f95f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ConcurrencyTest.cs +++ b/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 @@ public void CurrentScheduler_EnsureTrampoline() Assert.True(passed); } - [Fact] + [TestMethod] public void CurrentScheduler_Schedule() { const int concurrency = 100; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ControlSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ControlSchedulerTest.cs index 899b9b5b29..72e54e9738 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ControlSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ControlSchedulerTest.cs @@ -10,35 +10,37 @@ 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(() => 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 @@ public void Schedule_ArgumentChecking() ReactiveAssert.Throws(() => s.Schedule(42, DateTimeOffset.Now, default(Func))); } - [Fact] + [TestMethod] public void Schedule() { using (WinFormsTestUtils.RunTest(out var lbl)) @@ -65,7 +67,7 @@ public void Schedule() } } - [Fact] + [TestMethod] public void ScheduleError() { using (WinFormsTestUtils.RunTest(out var lbl)) @@ -90,13 +92,13 @@ public void ScheduleError() } } - [Fact] + [TestMethod] public void ScheduleRelative() { ScheduleRelative_(TimeSpan.FromSeconds(0.1)); } - [Fact] + [TestMethod] public void ScheduleRelative_Zero() { ScheduleRelative_(TimeSpan.Zero); @@ -129,7 +131,7 @@ private void ScheduleRelative_(TimeSpan delay) } } - [Fact] + [TestMethod] public void ScheduleRelative_Nested() { using (WinFormsTestUtils.RunTest(out var lbl)) @@ -160,7 +162,7 @@ public void ScheduleRelative_Nested() } } - [Fact] + [TestMethod] public void ScheduleRelative_Cancel() { using (WinFormsTestUtils.RunTest(out var lbl)) @@ -198,7 +200,7 @@ public void ScheduleRelative_Cancel() } } - [Fact] + [TestMethod] public void SchedulePeriodic_ArgumentChecking() { var s = new ControlScheduler(new Label()); @@ -207,7 +209,7 @@ public void SchedulePeriodic_ArgumentChecking() ReactiveAssert.Throws(() => 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 @@ public void SchedulePeriodic() } } - [Fact] + [TestMethod] public void SchedulePeriodic_Nested() { using (WinFormsTestUtils.RunTest(out var lbl)) @@ -292,4 +294,4 @@ public void SchedulePeriodic_Nested() } } } -#endif \ No newline at end of file +#endif diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/CurrentThreadSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/CurrentThreadSchedulerTest.cs index 21740f4118..ad3b96485f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/CurrentThreadSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/CurrentThreadSchedulerTest.cs @@ -7,14 +7,16 @@ 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(() => Scheduler.CurrentThread.Schedule(42, default)); @@ -22,7 +24,7 @@ public void CurrentThread_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.CurrentThread.Schedule(42, default(DateTimeOffset), default)); } - [Fact] + [TestMethod] public void CurrentThread_Now() { var res = Scheduler.CurrentThread.Now - DateTime.Now; @@ -30,7 +32,7 @@ public void CurrentThread_Now() } #if !NO_THREAD - [Fact] + [TestMethod] public void CurrentThread_ScheduleAction() { var id = Thread.CurrentThread.ManagedThreadId; @@ -40,7 +42,7 @@ public void CurrentThread_ScheduleAction() } #endif - [Fact] + [TestMethod] public void CurrentThread_ScheduleActionError() { var ex = new Exception(); @@ -56,7 +58,7 @@ public void CurrentThread_ScheduleActionError() } } #if !NO_THREAD - [Fact] + [TestMethod] public void CurrentThread_ScheduleActionNested() { var id = Thread.CurrentThread.ManagedThreadId; @@ -69,7 +71,7 @@ public void CurrentThread_ScheduleActionNested() Assert.True(ran); } - [Fact] + [TestMethod] public void CurrentThread_ScheduleActionNested_TimeSpan() { var id = Thread.CurrentThread.ManagedThreadId; @@ -82,7 +84,7 @@ public void CurrentThread_ScheduleActionNested_TimeSpan() Assert.True(ran); } - [Fact] + [TestMethod] public void CurrentThread_ScheduleActionDue() { var id = Thread.CurrentThread.ManagedThreadId; @@ -91,7 +93,7 @@ public void CurrentThread_ScheduleActionDue() Assert.True(ran, "ran"); } - [Fact] + [TestMethod] public void CurrentThread_ScheduleActionDueNested() { var id = Thread.CurrentThread.ManagedThreadId; @@ -109,7 +111,7 @@ public void CurrentThread_ScheduleActionDueNested() Assert.True(ran, "ran"); } #endif - [Fact] + [TestMethod] public void CurrentThread_EnsureTrampoline() { var ran1 = false; @@ -123,7 +125,7 @@ public void CurrentThread_EnsureTrampoline() Assert.True(ran2); } - [Fact] + [TestMethod] public void CurrentThread_EnsureTrampoline_Nested() { var ran1 = false; @@ -137,7 +139,7 @@ public void CurrentThread_EnsureTrampoline_Nested() Assert.True(ran2); } - [Fact] + [TestMethod] public void CurrentThread_EnsureTrampolineAndCancel() { var ran1 = false; @@ -155,7 +157,7 @@ public void CurrentThread_EnsureTrampolineAndCancel() Assert.False(ran2); } - [Fact] + [TestMethod] public void CurrentThread_EnsureTrampolineAndCancelTimed() { var ran1 = false; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DefaultSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DefaultSchedulerTest.cs index dc30d93f6c..96a4bdd5bd 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DefaultSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DefaultSchedulerTest.cs @@ -6,14 +6,16 @@ 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(() => DefaultScheduler.Instance.Schedule(42, default)); @@ -23,14 +25,14 @@ public void Schedule_ArgumentChecking() ReactiveAssert.Throws(() => 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 @@ public void ScheduleAction() evt.WaitOne(); } - [Fact] + [TestMethod] public void ScheduleActionDue() { var id = Thread.CurrentThread.ManagedThreadId; @@ -50,7 +52,7 @@ public void ScheduleActionDue() evt.WaitOne(); } - [Fact] + [TestMethod] public void ScheduleActionCancel() { var id = Thread.CurrentThread.ManagedThreadId; @@ -62,7 +64,7 @@ public void ScheduleActionCancel() Assert.False(set); } - [Fact] + [TestMethod] public void Periodic_NonReentrant() { var n = 0; @@ -94,8 +96,8 @@ public void Periodic_NonReentrant() } #endif #if DESKTOPCLR - [Trait("SkipCI", "true")] - [Fact] + [TestCategory("SkipCI")] + [TestMethod] public void No_ThreadPool_Starvation_Dispose() { ThreadPool.GetAvailableThreads(out var bwt, out var bio); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DispatcherSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DispatcherSchedulerTest.cs index 6d8ac35c32..1d2563103a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DispatcherSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/DispatcherSchedulerTest.cs @@ -10,20 +10,22 @@ 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(() => new DispatcherScheduler(null)); } - [Fact] + [TestMethod] public void Current() { using (DispatcherHelpers.RunTest(out var d)) @@ -40,7 +42,7 @@ public void Current() } } - [Fact] + [TestMethod] public void Current_None() { var e = default(Exception); @@ -63,7 +65,7 @@ public void Current_None() Assert.True(e != null && e is InvalidOperationException); } - [Fact] + [TestMethod] public void Dispatcher() { using (DispatcherHelpers.RunTest(out var disp)) @@ -72,7 +74,7 @@ public void Dispatcher() } } - [Fact] + [TestMethod] public void Now() { using (DispatcherHelpers.RunTest(out var disp)) @@ -82,7 +84,7 @@ public void Now() } } - [Fact] + [TestMethod] public void Schedule_ArgumentChecking() { using (DispatcherHelpers.RunTest(out var disp)) @@ -94,7 +96,7 @@ public void Schedule_ArgumentChecking() } } - [Fact] + [TestMethod] [Asynchronous] public void Schedule() { @@ -113,7 +115,7 @@ public void Schedule() } } - [Fact] + [TestMethod] public void ScheduleError() { using (DispatcherHelpers.RunTest(out var disp)) @@ -138,13 +140,13 @@ public void ScheduleError() } } - [Fact] + [TestMethod] public void ScheduleRelative() { ScheduleRelative_(TimeSpan.FromSeconds(0.2)); } - [Fact] + [TestMethod] public void ScheduleRelative_Zero() { ScheduleRelative_(TimeSpan.Zero); @@ -175,7 +177,7 @@ private void ScheduleRelative_(TimeSpan delay) } } - [Fact] + [TestMethod] public void ScheduleRelative_Cancel() { using (DispatcherHelpers.RunTest(out var disp)) @@ -212,7 +214,7 @@ public void ScheduleRelative_Cancel() } } - [Fact] + [TestMethod] public void SchedulePeriodic_ArgumentChecking() { using (DispatcherHelpers.RunTest(out var disp)) @@ -224,7 +226,7 @@ public void SchedulePeriodic_ArgumentChecking() } } - [Fact] + [TestMethod] public void SchedulePeriodic() { using (DispatcherHelpers.RunTest(out var disp)) diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/EventLoopSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/EventLoopSchedulerTest.cs index b1d5f2d979..be92a37485 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/EventLoopSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/EventLoopSchedulerTest.cs @@ -10,19 +10,21 @@ 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 @@ public void EventLoop_ArgumentChecking() ReactiveAssert.Throws(() => el.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _)); } - [Fact] + [TestMethod] public void EventLoop_Now() { using var el = new EventLoopScheduler(); @@ -46,7 +48,7 @@ public void EventLoop_Now() Assert.True(res.Seconds < 1); } - [Fact] + [TestMethod] public void EventLoop_DisposeWithInFlightActions() { using (var scheduler = new EventLoopScheduler()) @@ -59,7 +61,7 @@ public void EventLoop_DisposeWithInFlightActions() } } - [Fact] + [TestMethod] public void EventLoop_ScheduleAction() { var ran = false; @@ -75,7 +77,7 @@ public void EventLoop_ScheduleAction() } #if !NO_THREAD - [Fact] + [TestMethod] public void EventLoop_DifferentThread() { var id = default(int); @@ -91,7 +93,7 @@ public void EventLoop_DifferentThread() } #endif - [Fact] + [TestMethod] public void EventLoop_ScheduleOrderedActions() { var results = new List(); @@ -107,7 +109,7 @@ public void EventLoop_ScheduleOrderedActions() results.AssertEqual(0, 1); } - [Fact] + [TestMethod] public void EventLoop_SchedulerDisposed() { var d = 0; @@ -156,7 +158,7 @@ public void EventLoop_SchedulerDisposed() Assert.Equal(2, d); } - [Fact] + [TestMethod] public void EventLoop_ScheduleTimeOrderedActions() { var results = new List(); @@ -173,7 +175,7 @@ public void EventLoop_ScheduleTimeOrderedActions() results.AssertEqual(1, 0); } - [Fact] + [TestMethod] public void EventLoop_ScheduleOrderedAndTimedActions() { var results = new List(); @@ -190,7 +192,7 @@ public void EventLoop_ScheduleOrderedAndTimedActions() results.AssertEqual(1, 0); } - [Fact] + [TestMethod] public void EventLoop_ScheduleTimeOrderedInFlightActions() { var results = new List(); @@ -212,7 +214,7 @@ public void EventLoop_ScheduleTimeOrderedInFlightActions() results.AssertEqual(0, 1, 2); } - [Fact] + [TestMethod] public void EventLoop_ScheduleTimeAndOrderedInFlightActions() { var results = new List(); @@ -235,7 +237,7 @@ public void EventLoop_ScheduleTimeAndOrderedInFlightActions() results.AssertEqual(0, 4, 1, 2); } - [Fact] + [TestMethod] public void EventLoop_ScheduleActionNested() { var ran = false; @@ -250,7 +252,7 @@ public void EventLoop_ScheduleActionNested() Assert.True(ran); } - [Fact(Skip = "")] + [TestMethod] public void EventLoop_ScheduleActionDue() { var ran = false; @@ -269,7 +271,7 @@ public void EventLoop_ScheduleActionDue() Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds); } - [Fact(Skip = "")] + [TestMethod] public void EventLoop_ScheduleActionDueNested() { var ran = false; @@ -296,7 +298,7 @@ public void EventLoop_ScheduleActionDueNested() } #if !NO_PERF - [Fact] + [TestMethod] public void Stopwatch() { using var el = new EventLoopScheduler(); @@ -304,7 +306,7 @@ public void Stopwatch() } #endif - [Fact] + [TestMethod] public void EventLoop_Immediate() { var M = 1000; @@ -335,7 +337,7 @@ public void EventLoop_Immediate() } } - [Fact] + [TestMethod] public void EventLoop_TimeCollisions() { var M = 1000; @@ -366,7 +368,7 @@ public void EventLoop_TimeCollisions() } } - [Fact] + [TestMethod] public void EventLoop_Spread() { var M = 1000; @@ -397,7 +399,7 @@ public void EventLoop_Spread() } } - [Fact] + [TestMethod] public void EventLoop_Periodic() { var n = 0; @@ -424,7 +426,7 @@ public void EventLoop_Periodic() } #if STRESS - [Fact] + [TestMethod] public void EventLoop_Stress() { EventLoop.NoSemaphoreFullException(); @@ -432,7 +434,7 @@ public void EventLoop_Stress() #endif #if DESKTOPCLR - [Fact] + [TestMethod] public void EventLoop_CorrectWorkStealing() { const int workItemCount = 100; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/HistoricalSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/HistoricalSchedulerTest.cs index 1d12a3a932..ae23699fad 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/HistoricalSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/HistoricalSchedulerTest.cs @@ -8,11 +8,13 @@ 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 @@ public DateTimeOffset Time(int i) 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 @@ public void Ctor() Assert.Equal(false, s.IsEnabled); } - [Fact] + [TestMethod] public void Start_Stop() { var s = new HistoricalScheduler(); @@ -75,7 +77,7 @@ public void Start_Stop() ); } - [Fact] + [TestMethod] public void Order() { var s = new HistoricalScheduler(); @@ -99,7 +101,7 @@ public void Order() ); } - [Fact] + [TestMethod] public void Cancellation() { var s = new HistoricalScheduler(); @@ -121,7 +123,7 @@ public void Cancellation() ); } - [Fact] + [TestMethod] public void AdvanceTo_ArgumentChecking() { var now = DateTimeOffset.Now; @@ -131,7 +133,7 @@ public void AdvanceTo_ArgumentChecking() ReactiveAssert.Throws(() => s.AdvanceTo(now.Subtract(TimeSpan.FromSeconds(1)))); } - [Fact] + [TestMethod] public void AdvanceTo() { var s = new HistoricalScheduler(); @@ -210,7 +212,7 @@ public void AdvanceTo() ); } - [Fact] + [TestMethod] public void AdvanceBy_ArgumentChecking() { var s = new HistoricalScheduler(); @@ -218,7 +220,7 @@ public void AdvanceBy_ArgumentChecking() ReactiveAssert.Throws(() => s.AdvanceBy(TimeSpan.FromSeconds(-1))); } - [Fact] + [TestMethod] public void AdvanceBy() { var s = new HistoricalScheduler(); @@ -297,7 +299,7 @@ public void AdvanceBy() ); } - [Fact] + [TestMethod] public void IsEnabled() { var s = new HistoricalScheduler(); @@ -318,7 +320,7 @@ public void IsEnabled() Assert.Equal(false, s.IsEnabled); } - [Fact] + [TestMethod] public void No_Nested_AdvanceBy() { var s = new HistoricalScheduler(); @@ -328,7 +330,7 @@ public void No_Nested_AdvanceBy() ReactiveAssert.Throws(() => s.Start()); } - [Fact] + [TestMethod] public void No_Nested_AdvanceTo() { var s = new HistoricalScheduler(); @@ -338,7 +340,7 @@ public void No_Nested_AdvanceTo() ReactiveAssert.Throws(() => s.Start()); } - [Fact] + [TestMethod] public void Sleep_ArgumentChecking() { var s = new HistoricalScheduler(DateTimeOffset.Now); @@ -346,7 +348,7 @@ public void Sleep_ArgumentChecking() ReactiveAssert.Throws(() => 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 @@ public void Sleep1() Assert.Equal(now + TimeSpan.FromDays(1), s.Clock); } - [Fact] + [TestMethod] public void Sleep2() { var s = new HistoricalScheduler(); @@ -378,13 +380,13 @@ public void Sleep2() Assert.Equal(2, n); } - [Fact] + [TestMethod] public void WithComparer_ArgumentChecking() { ReactiveAssert.Throws(() => new HistoricalScheduler(DateTimeOffset.Now, null)); } - [Fact] + [TestMethod] public void WithComparer() { var now = DateTimeOffset.Now; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs index fddb4cff1c..653ac179ca 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs @@ -8,21 +8,23 @@ 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 @@ public void Immediate_ScheduleAction() } #endif - [Fact] + [TestMethod] public void Immediate_ScheduleActionError() { var ex = new Exception(); @@ -48,7 +50,7 @@ public void Immediate_ScheduleActionError() } } - [Fact] + [TestMethod] public void Immediate_ArgumentChecking() { ReactiveAssert.Throws(() => Scheduler.Immediate.Schedule(42, default)); @@ -56,7 +58,7 @@ public void Immediate_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.Immediate.Schedule(42, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Immediate_Simple1() { var _x = 0; @@ -64,7 +66,7 @@ public void Immediate_Simple1() Assert.Equal(42, _x); } - [Fact] + [TestMethod] public void Immediate_Simple2() { var _x = 0; @@ -72,7 +74,7 @@ public void Immediate_Simple2() Assert.Equal(42, _x); } - [Fact] + [TestMethod] public void Immediate_Simple3() { var _x = 0; @@ -80,7 +82,7 @@ public void Immediate_Simple3() Assert.Equal(42, _x); } - [Fact] + [TestMethod] public void Immediate_Recursive1() { var _x = 0; @@ -90,7 +92,7 @@ public void Immediate_Recursive1() Assert.Equal(43, _y); } - [Fact] + [TestMethod] public void Immediate_Recursive2() { var _x = 0; @@ -100,7 +102,7 @@ public void Immediate_Recursive2() Assert.Equal(43, _y); } - [Fact] + [TestMethod] public void Immediate_Recursive3() { var _x = 0; @@ -110,7 +112,7 @@ public void Immediate_Recursive3() Assert.Equal(43, _y); } - [Fact] + [TestMethod] public void Immediate_ArgumentChecking_More() { Scheduler.Immediate.Schedule(42, (self, state) => @@ -145,7 +147,7 @@ public void Immediate_ArgumentChecking_More() } #if !NO_THREAD - [Fact] + [TestMethod] public void Immediate_ScheduleActionDue() { var id = Thread.CurrentThread.ManagedThreadId; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs index 4cf83bf1f8..6ba99d4dba 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs @@ -7,14 +7,17 @@ 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(() => new NewThreadScheduler(null)); @@ -26,14 +29,14 @@ public void NewThread_ArgumentChecking() ReactiveAssert.Throws(() => 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 @@ public void NewThread_ScheduleAction() evt.WaitOne(); } - [Fact] + [TestMethod] public void NewThread_ScheduleActionDue() { var id = Thread.CurrentThread.ManagedThreadId; @@ -55,14 +58,14 @@ public void NewThread_ScheduleActionDue() #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 @@ public void NewThread_Periodic() } #if !NO_THREAD - [Fact] + [TestMethod] public void NewThread_Periodic_NonReentrant() { var n = 0; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ScheduledItemTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ScheduledItemTest.cs index 1eefe8a68f..69adf560ca 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ScheduledItemTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ScheduledItemTest.cs @@ -7,14 +7,16 @@ 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(() => new ScheduledItem(default, 42, (x, y) => Disposable.Empty, DateTimeOffset.Now)); @@ -25,7 +27,7 @@ public void ArgumentChecking() ReactiveAssert.Throws(() => new ScheduledItem(Scheduler.Default, 42, (x, y) => Disposable.Empty, DateTimeOffset.Now, default)); } - [Fact] + [TestMethod] public void Inequalities() { var si1 = new SI(42); @@ -79,7 +81,7 @@ public void Inequalities() Assert.False(si5 <= si4); } - [Fact] + [TestMethod] public void Equalities() { var si1 = new SI2(42, 123); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs index bc1b99171d..d1a4436556 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs @@ -11,7 +11,7 @@ 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.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 @@ public void Scheduler_ArgumentChecks() ReactiveAssert.Throws(() => Scheduler.Schedule(ms, 1, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Schedulers_ArgumentChecks() { ReactiveAssert.Throws(() => Scheduler.CurrentThread.Schedule(default(Action))); @@ -109,7 +110,7 @@ public void Schedulers_ArgumentChecks() ReactiveAssert.Throws(() => new SynchronizationContextScheduler(ctx).Schedule(DateTimeOffset.MaxValue, default(Action))); } - [Fact] + [TestMethod] public void Scheduler_ScheduleNonRecursive() { var ms = new MyScheduler(); @@ -118,7 +119,7 @@ public void Scheduler_ScheduleNonRecursive() Assert.True(res); } - [Fact] + [TestMethod] public void Scheduler_ScheduleRecursive() { var ms = new MyScheduler(); @@ -127,7 +128,7 @@ public void Scheduler_ScheduleRecursive() Assert.Equal(10, i); } - [Fact] + [TestMethod] public void Scheduler_Schedule_With_State() { var ms = new MyScheduler(); @@ -136,7 +137,7 @@ public void Scheduler_Schedule_With_State() Assert.True(res); } - [Fact] + [TestMethod] public void Scheduler_ScheduleWithTimeNonRecursive() { var now = DateTimeOffset.Now; @@ -147,7 +148,7 @@ public void Scheduler_ScheduleWithTimeNonRecursive() Assert.True(ms.WaitCycles == 0); } - [Fact] + [TestMethod] public void Scheduler_ScheduleWithTimeRecursive() { var now = DateTimeOffset.Now; @@ -158,7 +159,7 @@ public void Scheduler_ScheduleWithTimeRecursive() Assert.Equal(10, i); } - [Fact] + [TestMethod] public void Scheduler_ScheduleWithTimeSpanNonRecursive() { var now = DateTimeOffset.Now; @@ -169,7 +170,7 @@ public void Scheduler_ScheduleWithTimeSpanNonRecursive() Assert.True(ms.WaitCycles == 0); } - [Fact] + [TestMethod] public void Scheduler_ScheduleWithTimeSpanRecursive() { var now = DateTimeOffset.Now; @@ -180,7 +181,7 @@ public void Scheduler_ScheduleWithTimeSpanRecursive() Assert.Equal(10, i); } - [Fact] + [TestMethod] public void Scheduler_StateThreading() { var lst = new List(); @@ -196,7 +197,7 @@ public void Scheduler_StateThreading() Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void Scheduler_Builtins() { // Default @@ -243,7 +244,7 @@ private void Scheduler_Builtins_NoPlib() #if !NO_PERF #if !WINDOWS && !NO_THREAD - [Fact] + [TestMethod] public void Scheduler_LongRunning_ArgumentChecking() { ReactiveAssert.Throws(() => Scheduler.ScheduleLongRunning(null, c => { })); @@ -257,7 +258,7 @@ public void Scheduler_LongRunning_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.ScheduleLongRunning(ThreadPoolScheduler.Instance, default)); } - [Fact] + [TestMethod] public void Scheduler_Periodic_ArgumentChecking() { ReactiveAssert.Throws(() => Scheduler.SchedulePeriodic(null, TimeSpan.FromSeconds(1), () => { })); @@ -274,13 +275,13 @@ public void Scheduler_Periodic_ArgumentChecking() } #endif - [Fact] + [TestMethod] public void Scheduler_Stopwatch_Emulation() { ReactiveAssert.Throws(() => Scheduler.StartStopwatch(null)); } - [Fact] + [TestMethod] public void Scheduler_LongRunning1() { var s = TaskPoolScheduler.Default; @@ -304,7 +305,7 @@ public void Scheduler_LongRunning1() e.WaitOne(); } - [Fact] + [TestMethod] public void Scheduler_LongRunning2() { var s = TaskPoolScheduler.Default; @@ -336,7 +337,7 @@ public void Scheduler_LongRunning2() #if !NO_PERF #if !WINDOWS && !NO_THREAD - [Fact] + [TestMethod] public void Scheduler_Periodic1() { var n = 0; @@ -354,7 +355,7 @@ public void Scheduler_Periodic1() d.Dispose(); } - [Fact] + [TestMethod] public void Scheduler_Periodic2() { var n = 0; @@ -376,7 +377,7 @@ public void Scheduler_Periodic2() #endif #if DESKTOPCLR && NET472 - [Fact] + [TestMethod] public void Scheduler_Periodic_HostLifecycleManagement() { var cur = AppDomain.CurrentDomain.BaseDirectory; @@ -476,7 +477,7 @@ public void OnResuming() #region DisableOptimizations #if !NO_PERF - [Fact] + [TestMethod] public void DisableOptimizations_ArgumentChecking() { ReactiveAssert.Throws(() => Scheduler.DisableOptimizations(default)); @@ -489,7 +490,7 @@ public void DisableOptimizations_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.DisableOptimizations(Scheduler.Default).Schedule(42, DateTimeOffset.Now, default)); } - [Fact] + [TestMethod] public void DisableOptimizations1() { var s = TaskPoolScheduler.Default; @@ -525,7 +526,7 @@ public void DisableOptimizations1() e3.WaitOne(); } - [Fact] + [TestMethod] public void DisableOptimizations2() { var s = TaskPoolScheduler.Default; @@ -567,7 +568,7 @@ public void DisableOptimizations2() e2.WaitOne(); } - [Fact] + [TestMethod] public void DisableOptimizations3() { var s = TaskPoolScheduler.Default; @@ -622,7 +623,7 @@ public void DisableOptimizations3() } #endif - [Fact] + [TestMethod] public void DisableOptimizations_UnknownService() { var s = new MyScheduler(); @@ -676,7 +677,7 @@ public IDisposable Schedule(T state, DateTimeOffset dueTime, Func(() => Scheduler.Catch(default, _ => true)); @@ -687,7 +688,7 @@ public void Catch_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.Catch(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 @@ public void Catch_Builtin_Swallow_Shallow() done.WaitOne(); } - [Fact] + [TestMethod] public void Catch_Builtin_Swallow_Recursive() { var done = new ManualResetEvent(false); @@ -720,7 +721,7 @@ public void Catch_Builtin_Swallow_Recursive() done.WaitOne(); } - [Fact] + [TestMethod] public void Catch_Custom_Unhandled() { var err = default(Exception); @@ -740,7 +741,7 @@ public void Catch_Custom_Unhandled() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Catch_Custom_Rethrow() { var err = default(Exception); @@ -754,7 +755,7 @@ public void Catch_Custom_Rethrow() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Catch_Custom_LongRunning_Caught() { var err = default(Exception); @@ -779,7 +780,7 @@ public void Catch_Custom_LongRunning_Caught() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Catch_Custom_LongRunning_Rethrow() { var err = default(Exception); @@ -803,7 +804,7 @@ public void Catch_Custom_LongRunning_Rethrow() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Catch_Custom_Periodic_Regular() { var scheduler = new MyExceptionScheduler(_ => { }) @@ -830,7 +831,7 @@ public void Catch_Custom_Periodic_Regular() scheduler.PeriodicStopped.WaitOne(); } - [Fact] + [TestMethod] public void Catch_Custom_Periodic_Uncaught1() { var err = default(Exception); @@ -854,7 +855,7 @@ public void Catch_Custom_Periodic_Uncaught1() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Catch_Custom_Periodic_Uncaught2() { var err = default(Exception); @@ -878,7 +879,7 @@ public void Catch_Custom_Periodic_Uncaught2() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Catch_Custom_Periodic_Caught() { var err = default(Exception); @@ -984,7 +985,7 @@ public IDisposable SchedulePeriodic(TState state, TimeSpan period, Func< #region Services - [Fact] + [TestMethod] public void InvalidService_Null() { var s = new MySchedulerWithoutServices(); @@ -999,7 +1000,7 @@ public override IDisposable Schedule(TState state, TimeSpan dueTime, Fun } } - [Fact] + [TestMethod] public void DetectServices_Null_1() { var s = new MyDumbScheduler1(); @@ -1031,7 +1032,7 @@ public IDisposable Schedule(TState state, DateTimeOffset dueTime, Func()); @@ -1040,7 +1041,7 @@ public void DetectServices_Null_2() Assert.Null(Scheduler.AsStopwatchProvider(s)); } - [Fact] + [TestMethod] public void DetectServices_Found() { { @@ -1143,14 +1144,14 @@ public IDisposable SchedulePeriodic(TState state, TimeSpan period, Func< #endregion - [Fact] + [TestMethod] public void SchedulerAsync_Yield_ArgumentChecking() { ReactiveAssert.Throws(() => Scheduler.Yield(default)); ReactiveAssert.Throws(() => Scheduler.Yield(default, CancellationToken.None)); } - [Fact] + [TestMethod] public void SchedulerAsync_Sleep_ArgumentChecking() { ReactiveAssert.Throws(() => Scheduler.Sleep(default, TimeSpan.Zero)); @@ -1160,7 +1161,7 @@ public void SchedulerAsync_Sleep_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.Sleep(default, DateTimeOffset.MinValue, CancellationToken.None)); } - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_ArgumentChecking() { var tcs = new TaskCompletionSource(); @@ -1213,7 +1214,7 @@ public void SchedulerAsync_ScheduleAsync_ArgumentChecking() ReactiveAssert.Throws(() => Scheduler.ScheduleAsync(s, at, d4)); } - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_Overloads1() { var tcsI = new TaskCompletionSource(); @@ -1262,7 +1263,7 @@ public void SchedulerAsync_ScheduleAsync_Overloads1() ); } - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_Overloads2() { var tcsI = new TaskCompletionSource(); @@ -1311,7 +1312,7 @@ public void SchedulerAsync_ScheduleAsync_Overloads2() ); } - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_Overloads3() { var tcsI = new TaskCompletionSource(); @@ -1360,7 +1361,7 @@ public void SchedulerAsync_ScheduleAsync_Overloads3() ); } - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_NoCancellation1() { var s = new TestScheduler(); @@ -1394,7 +1395,7 @@ public void SchedulerAsync_ScheduleAsync_NoCancellation1() ); } - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_NoCancellation2() { var s = new TestScheduler(); @@ -1428,7 +1429,7 @@ public void SchedulerAsync_ScheduleAsync_NoCancellation2() ); } - [Fact] + [TestMethod] public void SchedulerAsync_Awaiters() { var op = Scheduler.Immediate.Yield(); @@ -1441,7 +1442,7 @@ public void SchedulerAsync_Awaiters() ReactiveAssert.Throws(() => aw.OnCompleted(() => { })); } - [Fact] + [TestMethod] public void SchedulerAsync_Yield_Cancel1() { var cts = new CancellationTokenSource(); @@ -1456,7 +1457,7 @@ public void SchedulerAsync_Yield_Cancel1() ReactiveAssert.Throws(() => aw.GetResult()); } - [Fact] + [TestMethod] public void SchedulerAsync_Yield_Cancel2() { var cts = new CancellationTokenSource(); @@ -1479,7 +1480,7 @@ public void SchedulerAsync_Yield_Cancel2() }); } - [Fact] + [TestMethod] public void SchedulerAsync_Sleep_Cancel() { var cts = new CancellationTokenSource(); @@ -1505,7 +1506,7 @@ public void SchedulerAsync_Sleep_Cancel() #if !NO_SYNCCTX - [Fact] + [TestMethod] public void SchedulerAsync_ScheduleAsync_SyncCtx() { var old = SynchronizationContext.Current; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationContextSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationContextSchedulerTest.cs index 04b5854b13..7418a692f0 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationContextSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationContextSchedulerTest.cs @@ -8,14 +8,16 @@ 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 @@ public void SynchronizationContext_ArgumentChecking() ReactiveAssert.Throws(() => s.Schedule(42, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void SynchronizationContext_Now() { var ms = new MySync(); @@ -38,7 +40,7 @@ public void SynchronizationContext_Now() Assert.True(res.Seconds < 1); } - [Fact] + [TestMethod] public void SynchronizationContext_ScheduleAction() { var ms = new MySync(); @@ -50,7 +52,7 @@ public void SynchronizationContext_ScheduleAction() Assert.True(ran); } - [Fact] + [TestMethod] public void SynchronizationContext_ScheduleAction_TimeSpan() { var ms = new MySync(); @@ -63,7 +65,7 @@ public void SynchronizationContext_ScheduleAction_TimeSpan() Assert.True(ms.Count == 1); } - [Fact] + [TestMethod] public void SynchronizationContext_ScheduleAction_DateTimeOffset() { var ms = new MySync(); @@ -76,7 +78,7 @@ public void SynchronizationContext_ScheduleAction_DateTimeOffset() 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 @@ public void SynchronizationContext_ScheduleActionError() Assert.True(ms.Count == 1); } - [Fact] + [TestMethod] public void SynchronizationContext_ScheduleActionDue() { var ms = new MySync(); @@ -144,7 +146,7 @@ public override void OperationCompleted() } } - [Fact] + [TestMethod] public void SynchronizationContext_StartedCompleted() { var ms = new MySync(); @@ -158,7 +160,7 @@ public void SynchronizationContext_StartedCompleted() Assert.True(ms.Completed == 1); } - [Fact] + [TestMethod] public void SynchronizationContext_DontPost_Different() { var ms = new MySync(); @@ -171,7 +173,7 @@ public void SynchronizationContext_DontPost_Different() } #if !NO_THREAD - [Fact] + [TestMethod] public void SynchronizationContext_DontPost_Same() { var count = 0; @@ -196,7 +198,7 @@ public void SynchronizationContext_DontPost_Same() } #endif - [Fact] + [TestMethod] public void SynchronizationContext_AlwaysPost_Different() { var ms = new MySync(); @@ -209,7 +211,7 @@ public void SynchronizationContext_AlwaysPost_Different() } #if !NO_THREAD - [Fact] + [TestMethod] public void SynchronizationContext_AlwaysPost_Same() { var count = 0; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationTest.cs index 39df3d215d..7211f7d40c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/SynchronizationTest.cs @@ -7,14 +7,14 @@ 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(() => Synchronization.SubscribeOn(default(IObservable), Scheduler.Immediate)); @@ -23,7 +23,7 @@ public void Synchronization_SubscribeOn_ArgumentChecking() ReactiveAssert.Throws(() => Synchronization.SubscribeOn(DummyObservable.Instance, default(SynchronizationContext))); } - [Fact] + [TestMethod] public void Synchronization_ObserveOn_ArgumentChecking() { ReactiveAssert.Throws(() => Synchronization.ObserveOn(default(IObservable), Scheduler.Immediate)); @@ -32,7 +32,7 @@ public void Synchronization_ObserveOn_ArgumentChecking() ReactiveAssert.Throws(() => Synchronization.ObserveOn(DummyObservable.Instance, default(SynchronizationContext))); } - [Fact] + [TestMethod] public void Synchronization_Synchronize_ArgumentChecking() { ReactiveAssert.Throws(() => Synchronization.Synchronize(default(IObservable))); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TaskPoolSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TaskPoolSchedulerTest.cs index 723adbb722..301ee79e55 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TaskPoolSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TaskPoolSchedulerTest.cs @@ -6,14 +6,16 @@ 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(() => new TaskPoolScheduler(null)); @@ -24,7 +26,7 @@ public void TaskPool_ArgumentChecking() ReactiveAssert.Throws(() => TaskPoolScheduler.Default.SchedulePeriodic(42, TimeSpan.FromSeconds(-1), _ => _)); } - [Fact] + [TestMethod] public void TaskPool_Now() { var res = TaskPoolScheduler.Default.Now - DateTime.Now; @@ -32,7 +34,7 @@ public void TaskPool_Now() } #if !NO_THREAD - [Fact] + [TestMethod] public void TaskPool_ScheduleAction() { var id = Thread.CurrentThread.ManagedThreadId; @@ -42,7 +44,7 @@ public void TaskPool_ScheduleAction() evt.WaitOne(); } - [Fact] + [TestMethod] public void TaskPool_ScheduleActionDueNow() { var id = Thread.CurrentThread.ManagedThreadId; @@ -52,7 +54,7 @@ public void TaskPool_ScheduleActionDueNow() evt.WaitOne(); } - [Fact] + [TestMethod] public void TaskPool_ScheduleActionDue() { var id = Thread.CurrentThread.ManagedThreadId; @@ -62,7 +64,7 @@ public void TaskPool_ScheduleActionDue() evt.WaitOne(); } - [Fact] + [TestMethod] public void TaskPool_ScheduleActionCancel() { var id = Thread.CurrentThread.ManagedThreadId; @@ -75,7 +77,7 @@ public void TaskPool_ScheduleActionCancel() } #if !NO_PERF - [Fact] + [TestMethod] public void TaskPool_ScheduleLongRunning() { var n = 0; @@ -117,14 +119,14 @@ public void TaskPool_ScheduleLongRunning() #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 @@ public void TaskPool_Periodic() } #if !NO_THREAD - [Fact] + [TestMethod] public void TaskPool_Periodic_NonReentrant() { var n = 0; @@ -179,7 +181,7 @@ public void TaskPool_Periodic_NonReentrant() } #endif - [Fact] + [TestMethod] public void TaskPool_Delay_LargerThanIntMaxValue() { var dueTime = TimeSpan.FromMilliseconds((double)int.MaxValue + 1); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TestSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TestSchedulerTest.cs index 5a2ec710b6..2fe9589304 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TestSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/TestSchedulerTest.cs @@ -10,14 +10,14 @@ 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(() => new TestScheduler().Start(null)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ThreadPoolSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ThreadPoolSchedulerTest.cs index 1914daa4e6..ed648a9702 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ThreadPoolSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ThreadPoolSchedulerTest.cs @@ -9,14 +9,16 @@ 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(() => ThreadPoolScheduler.Instance.Schedule(42, default)); @@ -24,14 +26,14 @@ public void Schedule_ArgumentChecking() ReactiveAssert.Throws(() => 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 @@ public void ScheduleAction() evt.WaitOne(); } - [Fact] + [TestMethod] public void ProperRooting_NoGC_SingleShot() { var cts = new CancellationTokenSource(); @@ -68,7 +70,7 @@ public void ProperRooting_NoGC_SingleShot() cts.Cancel(); } - [Fact] + [TestMethod] public void ProperRooting_NoGC_Periodic() { var cts = new CancellationTokenSource(); @@ -96,7 +98,7 @@ public void ProperRooting_NoGC_Periodic() cts.Cancel(); } - [Fact] + [TestMethod] public void ScheduleActionDueRelative() { var id = Thread.CurrentThread.ManagedThreadId; @@ -106,7 +108,7 @@ public void ScheduleActionDueRelative() evt.WaitOne(); } - [Fact] + [TestMethod] public void ScheduleActionDue0() { var id = Thread.CurrentThread.ManagedThreadId; @@ -116,7 +118,7 @@ public void ScheduleActionDue0() evt.WaitOne(); } - [Fact] + [TestMethod] public void ScheduleActionDueAbsolute() { var id = Thread.CurrentThread.ManagedThreadId; @@ -126,7 +128,7 @@ public void ScheduleActionDueAbsolute() evt.WaitOne(); } - [Fact] + [TestMethod] public void ScheduleActionCancel() { var id = Thread.CurrentThread.ManagedThreadId; @@ -140,13 +142,15 @@ public void ScheduleActionCancel() #if !NO_PERF - [Fact] +#if !WINDOWS_UWP + + [TestMethod] public void ScheduleLongRunning_ArgumentChecking() { ReactiveAssert.Throws(() => ThreadPoolScheduler.Instance.ScheduleLongRunning(42, default)); } - [Fact] + [TestMethod] public void ScheduleLongRunning() { var id = Thread.CurrentThread.ManagedThreadId; @@ -156,7 +160,7 @@ public void ScheduleLongRunning() evt.WaitOne(); } - [Fact] + [TestMethod] public void ScheduleLongRunningCancel() { var nt = ThreadPoolScheduler.Instance; @@ -186,7 +190,9 @@ public void ScheduleLongRunningCancel() Assert.True(n >= 10); } - [Fact] +#endif + + [TestMethod] public void Stopwatch() { var nt = ThreadPoolScheduler.Instance; @@ -200,25 +206,29 @@ public void Stopwatch() Assert.True(s1 > s0); } - [Fact] + [TestMethod] public void Periodic_ArgumentChecking() { ReactiveAssert.Throws(() => ThreadPoolScheduler.Instance.SchedulePeriodic(0, TimeSpan.FromSeconds(1), null)); ReactiveAssert.Throws(() => 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 @@ private void Periodic_Impl(TimeSpan period) Assert.True(res.Take(10).SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void Periodic_NonReentrant() { var n = 0; @@ -304,8 +314,8 @@ public void Periodic_NonReentrant() #endif #if DESKTOPCLR - [Trait("SkipCI", "true")] - [Fact] + [TestCategory("SkipCI")] + [TestMethod] public void No_ThreadPool_Starvation_Dispose() { ThreadPool.GetAvailableThreads(out var bwt, out var bio); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/VirtualSchedulerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/VirtualSchedulerTest.cs index b25e440b82..b39a8dc76a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/VirtualSchedulerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/VirtualSchedulerTest.cs @@ -10,11 +10,13 @@ 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 @@ -44,14 +46,14 @@ protected override char ToRelative(TimeSpan timeSpan) } } - [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 @@ public void Virtual_ScheduleAction() } #endif - [Fact] + [TestMethod] public void Virtual_ScheduleActionError() { var ex = new Exception(); @@ -81,14 +83,14 @@ public void Virtual_ScheduleActionError() } } - [Fact] + [TestMethod] public void Virtual_InitialAndComparer_Now() { var s = new VirtualSchedulerTestScheduler("Bar", Comparer.Default); Assert.Equal(3, s.Now.Ticks); } - [Fact] + [TestMethod] public void Virtual_ArgumentChecking() { ReactiveAssert.Throws(() => new VirtualSchedulerTestScheduler("", null)); @@ -104,7 +106,7 @@ public void Virtual_ArgumentChecking() ReactiveAssert.Throws(() => VirtualTimeSchedulerExtensions.ScheduleRelative(new VirtualSchedulerTestScheduler(), 'a', default)); } - [Fact] + [TestMethod] public void Historical_ArgumentChecking() { ReactiveAssert.Throws(() => new HistoricalScheduler(DateTime.Now, default)); @@ -113,7 +115,7 @@ public void Historical_ArgumentChecking() } #if !NO_THREAD - [Fact] + [TestMethod] public void Virtual_ScheduleActionDue() { var id = Thread.CurrentThread.ManagedThreadId; @@ -125,8 +127,8 @@ public void Virtual_ScheduleActionDue() } #endif - [Fact] - [Trait("SkipCI", "true")] + [TestMethod] + [TestCategory("SkipCI")] public void Virtual_ThreadSafety() { for (var i = 0; i < 10; i++) diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ConnectableObservableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ConnectableObservableTest.cs index 19e59bee57..c2bee689d9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ConnectableObservableTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ConnectableObservableTest.cs @@ -8,14 +8,16 @@ 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 @@ public void ConnectableObservable_Creation() Assert.Equal(1, y); } - [Fact] + [TestMethod] public void ConnectableObservable_Connected() { var scheduler = new TestScheduler(); @@ -59,7 +61,7 @@ public void ConnectableObservable_Connected() ); } - [Fact] + [TestMethod] public void ConnectableObservable_NotConnected() { var scheduler = new TestScheduler(); @@ -82,7 +84,7 @@ public void ConnectableObservable_NotConnected() ); } - [Fact] + [TestMethod] public void ConnectableObservable_Disconnected() { var scheduler = new TestScheduler(); @@ -107,7 +109,7 @@ public void ConnectableObservable_Disconnected() ); } - [Fact] + [TestMethod] public void ConnectableObservable_DisconnectFuture() { var scheduler = new TestScheduler(); @@ -134,13 +136,13 @@ public void ConnectableObservable_DisconnectFuture() ); } - [Fact] + [TestMethod] public void ConnectableObservable_ArgumentChecking() { ReactiveAssert.Throws(() => DummyObservable.Instance.Publish().Subscribe(default)); } - [Fact] + [TestMethod] public void ConnectableObservable_MultipleNonOverlappedConnections() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs index 3434d8b466..154a0f3f99 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs @@ -8,11 +8,13 @@ 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 @@ private void Run(CrossAppDomainDelegate a) _domain.DoCallBack(a); } - [Fact] + [TestMethod] public void Sleep() { var ran = new MarshalByRefCell(); @@ -49,7 +51,7 @@ public void Sleep() Assert.True(ran.Value); } - [Fact] + [TestMethod] public void QueueUserWorkItem() { var e = new MarshalByRefCell { Value = new ManualResetEvent(false) }; @@ -67,7 +69,7 @@ public void QueueUserWorkItem() e.Value.WaitOne(); } - [Fact] + [TestMethod] public void StartTimer() { var e = new MarshalByRefCell { Value = new ManualResetEvent(false) }; @@ -85,7 +87,7 @@ public void StartTimer() e.Value.WaitOne(); } - [Fact] + [TestMethod] public void StartTimer_Cancel() { Run(StartTimer_Cancel_Callback); @@ -99,7 +101,7 @@ private static void StartTimer_Cancel_Callback() }).Dispose(); } - [Fact] + [TestMethod] public void StartPeriodicTimer() { var e = new MarshalByRefCell { Value = new ManualResetEvent(false) }; @@ -123,7 +125,7 @@ public void StartPeriodicTimer() e.Value.WaitOne(); } - [Fact] + [TestMethod] public void StartPeriodicTimer_Cancel() { Run(StartPeriodicTimer_Cancel_Callback); @@ -137,7 +139,7 @@ private static void StartPeriodicTimer_Cancel_Callback() }).Dispose(); } - [Fact] + [TestMethod] public void StartPeriodicTimer_Fast() { var e = new MarshalByRefCell { Value = new ManualResetEvent(false) }; @@ -161,7 +163,7 @@ public void StartPeriodicTimer_Fast() e.Value.WaitOne(); } - [Fact] + [TestMethod] public void StartPeriodicTimer_Fast_Cancel() { var e = new MarshalByRefCell { Value = new ManualResetEvent(false) }; @@ -208,7 +210,7 @@ public void StartPeriodicTimer_Fast_Cancel() Assert.Equal(newValue, value); } - [Fact] + [TestMethod] public void CreateThread() { var e = new MarshalByRefCell { Value = new ManualResetEvent(false) }; @@ -283,7 +285,7 @@ public void CreateThread() Assert.True(string.IsNullOrEmpty(r.Value)); } - [Fact] + [TestMethod] public void Cant_Locate_Scheduler() { @@ -314,7 +316,7 @@ private void Cant_Locate_Scheduler_NoPlib() } #if !NO_PERF - [Fact] + [TestMethod] public void Stopwatch() { var e = new MarshalByRefCell(); @@ -337,7 +339,7 @@ public void Stopwatch() } #endif - [Fact] + [TestMethod] public void EnsureLoaded() { Assert.True(EnlightenmentProvider.EnsureLoaded()); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Disposables/DisposableTests.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Disposables/DisposableTests.cs index bca07292d1..bf070382a9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Disposables/DisposableTests.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Disposables/DisposableTests.cs @@ -10,27 +10,29 @@ 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 @@ public void AnonymousDisposable_Dispose() Assert.True(c.IsDisposed); } - [Fact] + [TestMethod] public void EmptyDisposable() { var d = Disposable.Empty; @@ -52,7 +54,7 @@ public void EmptyDisposable() d.Dispose(); } - [Fact] + [TestMethod] public void BooleanDisposable() { var d = new BooleanDisposable(); @@ -63,7 +65,7 @@ public void BooleanDisposable() Assert.True(d.IsDisposed); } - [Fact] + [TestMethod] public void SingleAssignmentDisposable_SetNull() { var d = new SingleAssignmentDisposable @@ -72,7 +74,7 @@ public void SingleAssignmentDisposable_SetNull() }; } - [Fact] + [TestMethod] public void SingleAssignmentDisposable_DisposeAfterSet() { var disposed = false; @@ -92,7 +94,7 @@ public void SingleAssignmentDisposable_DisposeAfterSet() Assert.True(d.IsDisposed); } - [Fact] + [TestMethod] public void SingleAssignmentDisposable_DisposeBeforeSet() { var disposed = false; @@ -114,7 +116,7 @@ public void SingleAssignmentDisposable_DisposeBeforeSet() Assert.True(disposed); } - [Fact] + [TestMethod] public void SingleAssignmentDisposable_SetMultipleTimes() { var d = new SingleAssignmentDisposable @@ -125,7 +127,7 @@ public void SingleAssignmentDisposable_SetMultipleTimes() ReactiveAssert.Throws(() => { d.Disposable = Disposable.Empty; }); } - [Fact] + [TestMethod] public void CompositeDisposable_ArgumentChecking() { ReactiveAssert.Throws(() => new CompositeDisposable(default(IDisposable[]))); @@ -133,7 +135,7 @@ public void CompositeDisposable_ArgumentChecking() ReactiveAssert.Throws(() => new CompositeDisposable(-1)); } - [Fact] + [TestMethod] public void CompositeDisposable_Contains() { var d1 = Disposable.Create(() => { }); @@ -147,31 +149,31 @@ public void CompositeDisposable_Contains() ReactiveAssert.Throws(() => g.Contains(null)); } - [Fact] + [TestMethod] public void CompositeDisposable_IsReadOnly() { Assert.False(new CompositeDisposable().IsReadOnly); } - [Fact] + [TestMethod] public void CompositeDisposable_CopyTo_Null() { ReactiveAssert.Throws(() => new CompositeDisposable().CopyTo(null, 0)); } - [Fact] + [TestMethod] public void CompositeDisposable_CopyTo_Negative() { ReactiveAssert.Throws(() => new CompositeDisposable().CopyTo(new IDisposable[2], -1)); } - [Fact] + [TestMethod] public void CompositeDisposable_CopyTo_BeyondEnd() { ReactiveAssert.Throws(() => new CompositeDisposable().CopyTo(new IDisposable[2], 2)); } - [Fact] + [TestMethod] public void CompositeDisposable_CopyTo() { var d1 = Disposable.Create(() => { }); @@ -184,7 +186,7 @@ public void CompositeDisposable_CopyTo() Assert.Same(d2, d[2]); } - [Fact] + [TestMethod] public void CompositeDisposable_ToArray() { var d1 = Disposable.Create(() => { }); @@ -195,7 +197,7 @@ public void CompositeDisposable_ToArray() Assert.True(g.ToArray().SequenceEqual(new[] { d1, d2 })); } - [Fact] + [TestMethod] public void CompositeDisposable_GetEnumerator() { var d1 = Disposable.Create(() => { }); @@ -210,7 +212,7 @@ public void CompositeDisposable_GetEnumerator() Assert.True(lst.SequenceEqual(new[] { d1, d2 })); } - [Fact] + [TestMethod] public void CompositeDisposable_GetEnumeratorNonGeneric() { var d1 = Disposable.Create(() => { }); @@ -225,7 +227,7 @@ public void CompositeDisposable_GetEnumeratorNonGeneric() Assert.True(lst.SequenceEqual(new[] { d1, d2 })); } - [Fact] + [TestMethod] public void CompositeDisposable_CollectionInitializer() { var d1 = Disposable.Create(() => { }); @@ -236,27 +238,27 @@ public void CompositeDisposable_CollectionInitializer() Assert.True(g.Contains(d2)); } - [Fact] + [TestMethod] public void CompositeDisposable_AddNull_via_params_ctor() { IDisposable d1 = null; ReactiveAssert.Throws(() => new CompositeDisposable(d1)); } - [Fact] + [TestMethod] public void CompositeDisposable_AddNull_via_IEnum_ctor() { IEnumerable values = new IDisposable[] { null }; ReactiveAssert.Throws(() => new CompositeDisposable(values)); } - [Fact] + [TestMethod] public void CompositeDisposable_AddNull() { ReactiveAssert.Throws(() => new CompositeDisposable().Add(null)); } - [Fact] + [TestMethod] public void CompositeDisposable_Add() { var d1 = Disposable.Create(() => { }); @@ -269,7 +271,7 @@ public void CompositeDisposable_Add() Assert.True(g.Contains(d2)); } - [Fact] + [TestMethod] public void CompositeDisposable_AddAfterDispose() { var disp1 = false; @@ -291,7 +293,7 @@ public void CompositeDisposable_AddAfterDispose() Assert.True(g.IsDisposed); } - [Fact] + [TestMethod] public void CompositeDisposable_Remove() { var disp1 = false; @@ -322,7 +324,7 @@ public void CompositeDisposable_Remove() Assert.False(disp3); } - [Fact] + [TestMethod] public void CompositeDisposable_Clear() { var disp1 = false; @@ -345,7 +347,7 @@ public void CompositeDisposable_Clear() Assert.Equal(1, g.Count); } - [Fact] + [TestMethod] public void CompositeDisposable_RemoveOptimizationBehavior() { var g = new CompositeDisposable(); @@ -393,13 +395,13 @@ public void CompositeDisposable_RemoveOptimizationBehavior() 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(() => new CompositeDisposable().Remove(null)); } - [Fact] + [TestMethod] public void CompositeDisposable_Empty_GetEnumerator() { var composite = new CompositeDisposable(); @@ -407,7 +409,7 @@ public void CompositeDisposable_Empty_GetEnumerator() Assert.False(composite.GetEnumerator().MoveNext()); } - [Fact] + [TestMethod] public void CompositeDisposable_NonCollection_Enumerable_Init() { var d = new BooleanDisposable(); @@ -424,7 +426,7 @@ private static IEnumerable Just(IDisposable d) yield return d; } - [Fact] + [TestMethod] public void CompositeDisposable_Disposed_Is_NoOp() { var d = new BooleanDisposable(); @@ -444,7 +446,7 @@ public void CompositeDisposable_Disposed_Is_NoOp() Assert.Null(array[0]); } - [Fact] + [TestMethod] public void CompositeDisposable_CopyTo_Index_Out_Of_Range() { var d1 = new BooleanDisposable(); @@ -465,7 +467,7 @@ public void CompositeDisposable_CopyTo_Index_Out_Of_Range() } } - [Fact] + [TestMethod] public void CompositeDisposable_GetEnumerator_Reset() { var d = new BooleanDisposable(); @@ -484,7 +486,7 @@ public void CompositeDisposable_GetEnumerator_Reset() Assert.Equal(d, enumerator.Current); } - [Fact] + [TestMethod] public void CompositeDisposable_GetEnumerator_Disposed_Entries() { var d1 = new BooleanDisposable(); @@ -506,13 +508,13 @@ public void CompositeDisposable_GetEnumerator_Disposed_Entries() Assert.False(enumerator.MoveNext()); } - [Fact] + [TestMethod] public void CancellationDisposable_Ctor_Null() { Assert.Throws(() => new CancellationDisposable(null)); } - [Fact] + [TestMethod] public void CancellationDisposable_DefaultCtor() { var c = new CancellationDisposable(); @@ -524,7 +526,7 @@ public void CancellationDisposable_DefaultCtor() Assert.True(c.Token.IsCancellationRequested); } - [Fact] + [TestMethod] public void CancellationDisposable_TokenCtor() { var t = new CancellationTokenSource(); @@ -537,19 +539,19 @@ public void CancellationDisposable_TokenCtor() Assert.True(c.Token.IsCancellationRequested); } - [Fact] + [TestMethod] public void ContextDisposable_CreateNullContext() { ReactiveAssert.Throws(() => new ContextDisposable(null, Disposable.Empty)); } - [Fact] + [TestMethod] public void ContextDisposable_CreateNullDisposable() { ReactiveAssert.Throws(() => new ContextDisposable(new SynchronizationContext(), null)); } - [Fact] + [TestMethod] public void ContextDisposable() { var disp = false; @@ -575,14 +577,14 @@ public override void Post(SendOrPostCallback d, object state) } } - [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 @@ public void SerialDisposable_ReplaceBeforeDispose() Assert.False(disp2); } - [Fact] + [TestMethod] public void SerialDisposable_ReplaceAfterDispose() { var disp1 = false; @@ -622,7 +624,7 @@ public void SerialDisposable_ReplaceAfterDispose() Assert.True(disp2); } - [Fact] + [TestMethod] public void SerialDisposable_Dispose() { var disp = false; @@ -639,13 +641,13 @@ public void SerialDisposable_Dispose() //Assert.Null(m.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal. } - [Fact] + [TestMethod] public void RefCountDisposable_Ctor_Null() { ReactiveAssert.Throws(() => new RefCountDisposable(null)); } - [Fact] + [TestMethod] public void RefCountDisposable_SingleReference() { var d = new BooleanDisposable(); @@ -657,7 +659,7 @@ public void RefCountDisposable_SingleReference() Assert.True(d.IsDisposed); } - [Fact] + [TestMethod] public void RefCountDisposable_RefCounting() { var d = new BooleanDisposable(); @@ -682,7 +684,7 @@ public void RefCountDisposable_RefCounting() d3.Dispose(); } - [Fact] + [TestMethod] public void RefCountDisposable_PrimaryDisposesFirst() { var d = new BooleanDisposable(); @@ -703,7 +705,7 @@ public void RefCountDisposable_PrimaryDisposesFirst() Assert.True(d.IsDisposed); } - [Fact] + [TestMethod] public void RefCountDisposable_Throw_If_Disposed() { var d = new BooleanDisposable(); @@ -715,14 +717,14 @@ public void RefCountDisposable_Throw_If_Disposed() ReactiveAssert.Throws(() => { r.GetDisposable(); }); } - [Fact] + [TestMethod] public void ScheduledDisposable_Null() { ReactiveAssert.Throws(() => new ScheduledDisposable(null, Disposable.Empty)); ReactiveAssert.Throws(() => new ScheduledDisposable(Scheduler.Immediate, null)); } - [Fact] + [TestMethod] public void ScheduledDisposable() { var d = new BooleanDisposable(); @@ -743,7 +745,7 @@ public void ScheduledDisposable() s.Disposable.Dispose(); // This should be a nop. } - [Fact] + [TestMethod] public void MultipleAssignmentDisposable() { var m = new MultipleAssignmentDisposable(); @@ -776,7 +778,7 @@ public void MultipleAssignmentDisposable() Assert.True(m.IsDisposed); } - [Fact] + [TestMethod] public void StableCompositeDisposable_ArgumentChecking() { var d = Disposable.Empty; @@ -792,7 +794,7 @@ public void StableCompositeDisposable_ArgumentChecking() ReactiveAssert.Throws(() => StableCompositeDisposable.Create(d, d, null)); } - [Fact] + [TestMethod] public void StableCompositeDisposable_Binary() { var disp1 = false; @@ -820,7 +822,7 @@ public void StableCompositeDisposable_Binary() Assert.True(d.IsDisposed); } - [Fact] + [TestMethod] public void StableCompositeDisposable_Nary1() { var disp1 = false; @@ -854,7 +856,7 @@ public void StableCompositeDisposable_Nary1() Assert.True(d.IsDisposed); } - [Fact] + [TestMethod] public void StableCompositeDisposable_Nary2() { var disp1 = false; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/EventPatternSourceBaseTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/EventPatternSourceBaseTest.cs index 584692acb7..9bb639d65d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/EventPatternSourceBaseTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/EventPatternSourceBaseTest.cs @@ -6,14 +6,14 @@ 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>(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ImmutableListTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ImmutableListTest.cs index 2be6f9afb0..9c4521ff2a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ImmutableListTest.cs +++ b/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.Empty; @@ -52,7 +54,7 @@ public void ImmutableList_Basics() Assert.True(list.Data.SequenceEqual(new int[] { })); } - [Fact] + [TestMethod] public void ImmutableList_Nulls() { var list = ImmutableList.Empty; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/ExceptionHelperTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/ExceptionHelperTest.cs index 59635deb0f..a349492ab8 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/ExceptionHelperTest.cs +++ b/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 @@ public void ExceptionHelper_TrySetException_Empty() Assert.Equal(ex, _errors); } - [Fact] + [TestMethod] public void ExceptionHelper_TrySetException_Not_Empty() { var ex1 = new InvalidOperationException(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/HalfSerializerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/HalfSerializerTest.cs index 0331b8df22..8a7fe28ca2 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/HalfSerializerTest.cs +++ b/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 @@ public void HalfSerializer_OnNext() Assert.Null(_consumer.Exc); } - [Fact] + [TestMethod] public void HalfSerializer_OnError() { var ex = new InvalidOperationException(); @@ -46,7 +49,7 @@ public void HalfSerializer_OnError() Assert.Equal(ex, _consumer.Exc); } - [Fact] + [TestMethod] public void HalfSerializer_OnError_Ignore_Further_Events() { var ex = new InvalidOperationException(); @@ -66,7 +69,7 @@ public void HalfSerializer_OnError_Ignore_Further_Events() Assert.Equal(ex, _consumer.Exc); } - [Fact] + [TestMethod] public void HalfSerializer_OnCompleted() { HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error); @@ -81,7 +84,7 @@ public void HalfSerializer_OnCompleted() Assert.Null(_consumer.Exc); } - [Fact] + [TestMethod] public void HalfSerializer_OnCompleted_Ignore_Further_Events() { HalfSerializer.ForwardOnCompleted(_consumer, ref _wip, ref _error); @@ -100,7 +103,7 @@ public void HalfSerializer_OnCompleted_Ignore_Further_Events() } // 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 @@ public void HalfSerializer_OnNext_Reentrant_Error() } // Practically simulates concurrent invocation of the HalfSerializer methods - [Fact] + [TestMethod] public void HalfSerializer_OnNext_Reentrant_OnCompleted() { var c = new ReentrantConsumer(this, false); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/PriorityQueueTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/PriorityQueueTest.cs index 6b4a8c182d..9fb1318c59 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Internal/PriorityQueueTest.cs +++ b/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(); @@ -28,7 +31,7 @@ public void Enqueue_dequeue() } } - [Fact] + [TestMethod] public void Enqueue_all_dequeue_all() { var q = new PriorityQueue(); @@ -51,7 +54,7 @@ public void Enqueue_all_dequeue_all() Assert.Equal(0, q.Count); } - [Fact] + [TestMethod] public void Reverse_Enqueue_all_dequeue_all() { var q = new PriorityQueue(); @@ -74,7 +77,7 @@ public void Reverse_Enqueue_all_dequeue_all() Assert.Equal(0, q.Count); } - [Fact] + [TestMethod] public void Remove_from_middle() { var q = new PriorityQueue(); @@ -97,7 +100,7 @@ public void Remove_from_middle() } } - [Fact] + [TestMethod] public void Repro_329() { var queue = new PriorityQueue(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/LicenseHeaderTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/LicenseHeaderTest.cs index d91cc6b9a9..0574401c95 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/LicenseHeaderTest.cs +++ b/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. /// + [TestClass] public class LicenseHeaderTest { private static readonly bool FixHeaders = true; @@ -22,7 +25,7 @@ public class LicenseHeaderTest "" }; - [Fact] + [TestMethod] public void ScanFiles() { var dir = Directory.GetCurrentDirectory(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AggregateTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AggregateTest.cs index 61aa7d3dff..815278bfae 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AggregateTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AggregateTest.cs @@ -7,13 +7,14 @@ 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(() => Observable.Aggregate(default, 1, (x, y) => x + y)); @@ -27,7 +28,7 @@ public void Aggregate_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Aggregate(DummyObservable.Instance, 1, (x, y) => x + y, default)); } - [Fact] + [TestMethod] public void AggregateWithSeed_Empty() { var scheduler = new TestScheduler(); @@ -51,7 +52,7 @@ public void AggregateWithSeed_Empty() ); } - [Fact] + [TestMethod] public void AggregateWithSeed_Return() { var scheduler = new TestScheduler(); @@ -76,7 +77,7 @@ public void AggregateWithSeed_Return() ); } - [Fact] + [TestMethod] public void AggregateWithSeed_Throw() { var ex = new Exception(); @@ -101,7 +102,7 @@ public void AggregateWithSeed_Throw() ); } - [Fact] + [TestMethod] public void AggregateWithSeed_Never() { var ex = new Exception(); @@ -124,7 +125,7 @@ public void AggregateWithSeed_Never() ); } - [Fact] + [TestMethod] public void AggregateWithSeed_Range() { var ex = new Exception(); @@ -155,7 +156,7 @@ public void AggregateWithSeed_Range() ); } - [Fact] + [TestMethod] public void AggregateWithSeed_AccumulatorThrows() { var ex = new Exception(); @@ -185,7 +186,7 @@ public void AggregateWithSeed_AccumulatorThrows() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_Empty() { var scheduler = new TestScheduler(); @@ -209,7 +210,7 @@ public void AggregateWithSeedAndResult_Empty() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_Return() { var scheduler = new TestScheduler(); @@ -234,7 +235,7 @@ public void AggregateWithSeedAndResult_Return() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_Throw() { var ex = new Exception(); @@ -259,7 +260,7 @@ public void AggregateWithSeedAndResult_Throw() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_Never() { var ex = new Exception(); @@ -282,7 +283,7 @@ public void AggregateWithSeedAndResult_Never() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_Range() { var ex = new Exception(); @@ -313,7 +314,7 @@ public void AggregateWithSeedAndResult_Range() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_AccumulatorThrows() { var ex = new Exception(); @@ -343,7 +344,7 @@ public void AggregateWithSeedAndResult_AccumulatorThrows() ); } - [Fact] + [TestMethod] public void AggregateWithSeedAndResult_ResultSelectorThrows() { var ex = new Exception(); @@ -373,7 +374,7 @@ public void AggregateWithSeedAndResult_ResultSelectorThrows() ); } - [Fact] + [TestMethod] public void AggregateWithoutSeed_Empty() { var scheduler = new TestScheduler(); @@ -396,7 +397,7 @@ public void AggregateWithoutSeed_Empty() ); } - [Fact] + [TestMethod] public void AggregateWithoutSeed_Return() { var scheduler = new TestScheduler(); @@ -421,7 +422,7 @@ public void AggregateWithoutSeed_Return() ); } - [Fact] + [TestMethod] public void AggregateWithoutSeed_Throw() { var ex = new Exception(); @@ -446,7 +447,7 @@ public void AggregateWithoutSeed_Throw() ); } - [Fact] + [TestMethod] public void AggregateWithoutSeed_Never() { var scheduler = new TestScheduler(); @@ -463,7 +464,7 @@ public void AggregateWithoutSeed_Never() ); } - [Fact] + [TestMethod] public void AggregateWithoutSeed_Range() { var scheduler = new TestScheduler(); @@ -492,7 +493,7 @@ public void AggregateWithoutSeed_Range() ); } - [Fact] + [TestMethod] public void AggregateWithoutSeed_AccumulatorThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AllTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AllTest.cs index 9e86e7d581..5a81c45489 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AllTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AllTest.cs @@ -8,20 +8,21 @@ 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(() => Observable.All(DummyObservable.Instance, default)); ReactiveAssert.Throws(() => Observable.All(default(IObservable), x => true)); } - [Fact] + [TestMethod] public void All_Empty() { var scheduler = new TestScheduler(); @@ -45,7 +46,7 @@ public void All_Empty() ); } - [Fact] + [TestMethod] public void All_Return() { var scheduler = new TestScheduler(); @@ -70,7 +71,7 @@ public void All_Return() ); } - [Fact] + [TestMethod] public void All_ReturnNotMatch() { var scheduler = new TestScheduler(); @@ -95,7 +96,7 @@ public void All_ReturnNotMatch() ); } - [Fact] + [TestMethod] public void All_SomeNoneMatch() { var scheduler = new TestScheduler(); @@ -122,7 +123,7 @@ public void All_SomeNoneMatch() ); } - [Fact] + [TestMethod] public void All_SomeMatch() { var scheduler = new TestScheduler(); @@ -149,7 +150,7 @@ public void All_SomeMatch() ); } - [Fact] + [TestMethod] public void All_SomeAllMatch() { var scheduler = new TestScheduler(); @@ -176,7 +177,7 @@ public void All_SomeAllMatch() ); } - [Fact] + [TestMethod] public void All_Throw() { var ex = new Exception(); @@ -201,7 +202,7 @@ public void All_Throw() ); } - [Fact] + [TestMethod] public void All_Never() { var ex = new Exception(); @@ -224,7 +225,7 @@ public void All_Never() ); } - [Fact] + [TestMethod] public void All_PredicateThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AmbTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AmbTest.cs index e4163982e0..c86a928c6a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AmbTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AmbTest.cs @@ -8,14 +8,17 @@ 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(() => Observable.Amb((IObservable[])null)); @@ -24,7 +27,7 @@ public void Amb_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Amb(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void Amb_Never2() { var scheduler = new TestScheduler(); @@ -53,7 +56,7 @@ public void Amb_Never2() ); } - [Fact] + [TestMethod] public void Amb_Never3() { var scheduler = new TestScheduler(); @@ -90,7 +93,7 @@ public void Amb_Never3() ); } - [Fact] + [TestMethod] public void Amb_Never3_Params() { var scheduler = new TestScheduler(); @@ -127,7 +130,7 @@ public void Amb_Never3_Params() ); } - [Fact] + [TestMethod] public void Amb_NeverEmpty() { var scheduler = new TestScheduler(); @@ -158,7 +161,7 @@ public void Amb_NeverEmpty() ); } - [Fact] + [TestMethod] public void Amb_EmptyNever() { var scheduler = new TestScheduler(); @@ -189,7 +192,7 @@ public void Amb_EmptyNever() ); } - [Fact] + [TestMethod] public void Amb_RegularShouldDisposeLoser() { var scheduler = new TestScheduler(); @@ -224,7 +227,7 @@ public void Amb_RegularShouldDisposeLoser() ); } - [Fact] + [TestMethod] public void Amb_WinnerThrows() { var scheduler = new TestScheduler(); @@ -261,7 +264,7 @@ public void Amb_WinnerThrows() ); } - [Fact] + [TestMethod] public void Amb_LoserThrows() { var scheduler = new TestScheduler(); @@ -298,7 +301,7 @@ public void Amb_LoserThrows() ); } - [Fact] + [TestMethod] public void Amb_ThrowsBeforeElectionLeft() { var scheduler = new TestScheduler(); @@ -333,7 +336,7 @@ public void Amb_ThrowsBeforeElectionLeft() ); } - [Fact] + [TestMethod] public void Amb_ThrowsBeforeElectionRight() { var scheduler = new TestScheduler(); @@ -368,7 +371,7 @@ public void Amb_ThrowsBeforeElectionRight() ); } - [Fact] + [TestMethod] public void Amb_Many_Array_OnNext() { var scheduler = new TestScheduler(); @@ -413,7 +416,7 @@ public void Amb_Many_Array_OnNext() ); } - [Fact] + [TestMethod] public void Amb_Many_Array_OnError() { var scheduler = new TestScheduler(); @@ -455,7 +458,7 @@ public void Amb_Many_Array_OnError() ); } - [Fact] + [TestMethod] public void Amb_Many_Array_OnCompleted() { var scheduler = new TestScheduler(); @@ -500,7 +503,7 @@ public void Amb_Many_Array_OnCompleted() } - [Fact] + [TestMethod] public void Amb_Many_Enumerable_OnNext() { var scheduler = new TestScheduler(); @@ -545,7 +548,7 @@ public void Amb_Many_Enumerable_OnNext() ); } - [Fact] + [TestMethod] public void Amb_Many_Enumerable_OnError() { var scheduler = new TestScheduler(); @@ -587,7 +590,7 @@ public void Amb_Many_Enumerable_OnError() ); } - [Fact] + [TestMethod] public void Amb_Many_Enumerable_OnCompleted() { var scheduler = new TestScheduler(); @@ -632,7 +635,7 @@ public void Amb_Many_Enumerable_OnCompleted() } - [Fact] + [TestMethod] public void Amb_Many_Enumerable_Many_Sources() { for (var i = 0; i < 32; i++) @@ -657,7 +660,7 @@ public void Amb_Many_Enumerable_Many_Sources() } } - [Fact] + [TestMethod] public void Amb_Many_Enumerable_Many_Sources_NoStackOverflow() { for (var i = 0; i < 100; i++) diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AndTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AndTest.cs index fe5c41043c..52fd7aa6f4 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AndTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AndTest.cs @@ -6,14 +6,15 @@ 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 @@ public void And_ArgumentChecking() ReactiveAssert.Throws(() => 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(null)); } - [Fact] + [TestMethod] public void And2() { var scheduler = new TestScheduler(); @@ -62,7 +63,7 @@ public void And2() ); } - [Fact] + [TestMethod] public void And2Error() { var ex = new Exception(); @@ -101,7 +102,7 @@ public void And2Error() } } - [Fact] + [TestMethod] public void And3() { var scheduler = new TestScheduler(); @@ -127,7 +128,7 @@ public void And3() ); } - [Fact] + [TestMethod] public void And3Error() { var ex = new Exception(); @@ -166,7 +167,7 @@ public void And3Error() } } - [Fact] + [TestMethod] public void And4() { var scheduler = new TestScheduler(); @@ -192,7 +193,7 @@ public void And4() ); } - [Fact] + [TestMethod] public void And4Error() { var ex = new Exception(); @@ -231,7 +232,7 @@ public void And4Error() } } - [Fact] + [TestMethod] public void And5() { var scheduler = new TestScheduler(); @@ -257,7 +258,7 @@ public void And5() ); } - [Fact] + [TestMethod] public void And5Error() { var ex = new Exception(); @@ -296,7 +297,7 @@ public void And5Error() } } - [Fact] + [TestMethod] public void And6() { var scheduler = new TestScheduler(); @@ -322,7 +323,7 @@ public void And6() ); } - [Fact] + [TestMethod] public void And6Error() { var ex = new Exception(); @@ -361,7 +362,7 @@ public void And6Error() } } - [Fact] + [TestMethod] public void And7() { var scheduler = new TestScheduler(); @@ -387,7 +388,7 @@ public void And7() ); } - [Fact] + [TestMethod] public void And7Error() { var ex = new Exception(); @@ -426,7 +427,7 @@ public void And7Error() } } - [Fact] + [TestMethod] public void And8() { var scheduler = new TestScheduler(); @@ -452,7 +453,7 @@ public void And8() ); } - [Fact] + [TestMethod] public void And8Error() { var ex = new Exception(); @@ -491,7 +492,7 @@ public void And8Error() } } - [Fact] + [TestMethod] public void And9() { var scheduler = new TestScheduler(); @@ -517,7 +518,7 @@ public void And9() ); } - [Fact] + [TestMethod] public void And9Error() { var ex = new Exception(); @@ -556,7 +557,7 @@ public void And9Error() } } - [Fact] + [TestMethod] public void And10() { var scheduler = new TestScheduler(); @@ -582,7 +583,7 @@ public void And10() ); } - [Fact] + [TestMethod] public void And10Error() { var ex = new Exception(); @@ -621,7 +622,7 @@ public void And10Error() } } - [Fact] + [TestMethod] public void And11() { var scheduler = new TestScheduler(); @@ -647,7 +648,7 @@ public void And11() ); } - [Fact] + [TestMethod] public void And11Error() { var ex = new Exception(); @@ -686,7 +687,7 @@ public void And11Error() } } - [Fact] + [TestMethod] public void And12() { var scheduler = new TestScheduler(); @@ -712,7 +713,7 @@ public void And12() ); } - [Fact] + [TestMethod] public void And12Error() { var ex = new Exception(); @@ -751,7 +752,7 @@ public void And12Error() } } - [Fact] + [TestMethod] public void And13() { var scheduler = new TestScheduler(); @@ -777,7 +778,7 @@ public void And13() ); } - [Fact] + [TestMethod] public void And13Error() { var ex = new Exception(); @@ -816,7 +817,7 @@ public void And13Error() } } - [Fact] + [TestMethod] public void And14() { var scheduler = new TestScheduler(); @@ -842,7 +843,7 @@ public void And14() ); } - [Fact] + [TestMethod] public void And14Error() { var ex = new Exception(); @@ -881,7 +882,7 @@ public void And14Error() } } - [Fact] + [TestMethod] public void And15() { var scheduler = new TestScheduler(); @@ -907,7 +908,7 @@ public void And15() ); } - [Fact] + [TestMethod] public void And15Error() { var ex = new Exception(); @@ -946,7 +947,7 @@ public void And15Error() } } - [Fact] + [TestMethod] public void And16() { var scheduler = new TestScheduler(); @@ -972,7 +973,7 @@ public void And16() ); } - [Fact] + [TestMethod] public void And16Error() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AnyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AnyTest.cs index e2609ca4c4..9952bb83cb 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AnyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AnyTest.cs @@ -7,13 +7,14 @@ 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(() => Observable.Any(default(IObservable))); @@ -21,7 +22,7 @@ public void Any_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Any(default(IObservable), x => true)); } - [Fact] + [TestMethod] public void Any_Empty() { var scheduler = new TestScheduler(); @@ -45,7 +46,7 @@ public void Any_Empty() ); } - [Fact] + [TestMethod] public void Any_Return() { var scheduler = new TestScheduler(); @@ -70,7 +71,7 @@ public void Any_Return() ); } - [Fact] + [TestMethod] public void Any_Throw() { var ex = new Exception(); @@ -95,7 +96,7 @@ public void Any_Throw() ); } - [Fact] + [TestMethod] public void Any_Never() { var ex = new Exception(); @@ -118,7 +119,7 @@ public void Any_Never() ); } - [Fact] + [TestMethod] public void Any_Predicate_Empty() { var scheduler = new TestScheduler(); @@ -142,7 +143,7 @@ public void Any_Predicate_Empty() ); } - [Fact] + [TestMethod] public void Any_Predicate_Return() { var scheduler = new TestScheduler(); @@ -167,7 +168,7 @@ public void Any_Predicate_Return() ); } - [Fact] + [TestMethod] public void Any_Predicate_ReturnNotMatch() { var scheduler = new TestScheduler(); @@ -192,7 +193,7 @@ public void Any_Predicate_ReturnNotMatch() ); } - [Fact] + [TestMethod] public void Any_Predicate_SomeNoneMatch() { var scheduler = new TestScheduler(); @@ -219,7 +220,7 @@ public void Any_Predicate_SomeNoneMatch() ); } - [Fact] + [TestMethod] public void Any_Predicate_SomeMatch() { var scheduler = new TestScheduler(); @@ -246,7 +247,7 @@ public void Any_Predicate_SomeMatch() ); } - [Fact] + [TestMethod] public void Any_Predicate_Throw() { var ex = new Exception(); @@ -271,7 +272,7 @@ public void Any_Predicate_Throw() ); } - [Fact] + [TestMethod] public void Any_Predicate_Never() { var scheduler = new TestScheduler(); @@ -292,7 +293,7 @@ public void Any_Predicate_Never() ); } - [Fact] + [TestMethod] public void Any_Predicate_PredicateThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendPrependTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendPrependTest.cs index ff0e82fa59..eb14e6f510 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendPrependTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendPrependTest.cs @@ -6,13 +6,16 @@ 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 @@ public void AppendPrepend() ); } - [Fact] + [TestMethod] public void PrependAppend() { var scheduler = new TestScheduler(); @@ -58,7 +61,7 @@ public void PrependAppend() ); } - [Fact] + [TestMethod] public void AppendPrepend_Scheduler() { var scheduler = new TestScheduler(); @@ -81,7 +84,7 @@ public void AppendPrepend_Scheduler() ); } - [Fact] + [TestMethod] public void PrependAppend_Scheduler() { var scheduler = new TestScheduler(); @@ -104,7 +107,7 @@ public void PrependAppend_Scheduler() ); } - [Fact] + [TestMethod] public void AppendPrepend_Many() { var scheduler = new TestScheduler(); @@ -131,7 +134,7 @@ public void AppendPrepend_Many() ); } - [Fact] + [TestMethod] public void PrependAppend_Many() { var scheduler = new TestScheduler(); @@ -158,7 +161,7 @@ public void PrependAppend_Many() ); } - [Fact] + [TestMethod] public void AppendPrepend_Many_Scheduler() { var scheduler = new TestScheduler(); @@ -190,7 +193,7 @@ public void AppendPrepend_Many_Scheduler() ); } - [Fact] + [TestMethod] public void PrependAppend_Many_Scheduler() { var scheduler = new TestScheduler(); @@ -222,7 +225,7 @@ public void PrependAppend_Many_Scheduler() ); } - [Fact] + [TestMethod] public void AppendPrepend_Mixed() { var scheduler = new TestScheduler(); @@ -249,7 +252,7 @@ public void AppendPrepend_Mixed() ); } - [Fact] + [TestMethod] public void AppendPrepend_Mixed_Scheduler() { var scheduler = new TestScheduler(); @@ -281,7 +284,7 @@ public void AppendPrepend_Mixed_Scheduler() ); } - [Fact] + [TestMethod] public void AppendPrepend_MixedSchedulers() { var scheduler = new TestScheduler(); @@ -313,7 +316,7 @@ public void AppendPrepend_MixedSchedulers() ); } - [Fact] + [TestMethod] public void AppendPrepend_SchedulerRecursive() { using var scheduler = new EventLoopScheduler(); @@ -333,7 +336,7 @@ public void AppendPrepend_SchedulerRecursive() } } - [Fact] + [TestMethod] public void AppendPrepend_SchedulerLongRunning() { var scheduler = NewThreadScheduler.Default; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendTest.cs index 2408b453e8..ac9576bcc2 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AppendTest.cs @@ -6,13 +6,14 @@ 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 @@ public void Append_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Append(someObservable, 1, default)); } - [Fact] + [TestMethod] public void Append() { var scheduler = new TestScheduler(); @@ -46,7 +47,7 @@ public void Append() ); } - [Fact] + [TestMethod] public void Append_Null() { var scheduler = new TestScheduler(); @@ -68,7 +69,7 @@ public void Append_Null() ); } - [Fact] + [TestMethod] public void Append_Scheduler() { var scheduler = new TestScheduler(); @@ -90,7 +91,7 @@ public void Append_Scheduler() ); } - [Fact] + [TestMethod] public void Append_Many() { var scheduler = new TestScheduler(); @@ -114,7 +115,7 @@ public void Append_Many() ); } - [Fact] + [TestMethod] public void Append_Many_Take() { var scheduler = new TestScheduler(); @@ -136,7 +137,7 @@ public void Append_Many_Take() ); } - [Fact] + [TestMethod] public void Append_Many_Scheduler() { var scheduler = new TestScheduler(); @@ -160,7 +161,7 @@ public void Append_Many_Scheduler() ); } - [Fact] + [TestMethod] public void Append_Many_Take_Scheduler() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AsObservableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AsObservableTest.cs index a32127d0e4..9e7f6babc5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AsObservableTest.cs +++ b/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(() => Observable.AsObservable(null)); } - [Fact] + [TestMethod] public void AsObservable_AsObservable() { var scheduler = new TestScheduler(); @@ -47,7 +50,7 @@ public void AsObservable_AsObservable() ); } - [Fact] + [TestMethod] public void AsObservable_Hides() { var xs = Observable.Empty(); @@ -57,7 +60,7 @@ public void AsObservable_Hides() Assert.NotSame(xs, res); } - [Fact] + [TestMethod] public void AsObservable_Never() { var scheduler = new TestScheduler(); @@ -72,7 +75,7 @@ public void AsObservable_Never() ); } - [Fact] + [TestMethod] public void AsObservable_Empty() { var scheduler = new TestScheduler(); @@ -95,7 +98,7 @@ public void AsObservable_Empty() ); } - [Fact] + [TestMethod] public void AsObservable_Throw() { var scheduler = new TestScheduler(); @@ -119,7 +122,7 @@ public void AsObservable_Throw() ); } - [Fact] + [TestMethod] public void AsObservable_Return() { var scheduler = new TestScheduler(); @@ -144,7 +147,7 @@ public void AsObservable_Return() ); } - [Fact] + [TestMethod] public void AsObservable_IsNotEager() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AutoConnectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AutoConnectTest.cs index 2a9fafb407..7fa6c25357 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AutoConnectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AutoConnectTest.cs @@ -8,13 +8,16 @@ 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 @@ public void AutoConnect_Basic() Assert.Equal(new List() { 1, 2, 3, 4, 5 }, list); } - [Fact] + [TestMethod] public void AutoConnect_Immediately() { var called = 0; @@ -66,7 +69,7 @@ public void AutoConnect_Immediately() Assert.Equal(new List() { 1, 2, 3, 4, 5 }, list); } - [Fact] + [TestMethod] public void AutoConnect_TwoConsumers() { var called = 0; @@ -101,7 +104,7 @@ public void AutoConnect_TwoConsumers() Assert.Equal(new List() { 1, 2, 3, 4, 5 }, list); } - [Fact] + [TestMethod] public void AutoConnect_Dispose() { var subject = new Subject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AverageTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AverageTest.cs index 930d129ccb..02d0fd547f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AverageTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AverageTest.cs @@ -7,13 +7,14 @@ 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(() => Observable.Average(default(IObservable))); @@ -50,7 +51,7 @@ public void Average_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Average(Observable.Empty(), default(Func))); } - [Fact] + [TestMethod] public void Average_Int32_Empty() { var scheduler = new TestScheduler(); @@ -73,7 +74,7 @@ public void Average_Int32_Empty() ); } - [Fact] + [TestMethod] public void Average_Int32_Return() { var scheduler = new TestScheduler(); @@ -98,7 +99,7 @@ public void Average_Int32_Return() ); } - [Fact] + [TestMethod] public void Average_Int32_Some() { var scheduler = new TestScheduler(); @@ -125,7 +126,7 @@ public void Average_Int32_Some() ); } - [Fact] + [TestMethod] public void Average_Int32_Throw() { var ex = new Exception(); @@ -150,7 +151,7 @@ public void Average_Int32_Throw() ); } - [Fact] + [TestMethod] public void Average_Int32_Never() { var ex = new Exception(); @@ -173,7 +174,7 @@ public void Average_Int32_Never() ); } - [Fact] + [TestMethod] public void Average_Int64_Empty() { var scheduler = new TestScheduler(); @@ -196,7 +197,7 @@ public void Average_Int64_Empty() ); } - [Fact] + [TestMethod] public void Average_Int64_Return() { var scheduler = new TestScheduler(); @@ -221,7 +222,7 @@ public void Average_Int64_Return() ); } - [Fact] + [TestMethod] public void Average_Int64_Some() { var scheduler = new TestScheduler(); @@ -248,7 +249,7 @@ public void Average_Int64_Some() ); } - [Fact] + [TestMethod] public void Average_Int64_Throw() { var ex = new Exception(); @@ -273,7 +274,7 @@ public void Average_Int64_Throw() ); } - [Fact] + [TestMethod] public void Average_Int64_Never() { var ex = new Exception(); @@ -296,7 +297,7 @@ public void Average_Int64_Never() ); } - [Fact] + [TestMethod] public void Average_Double_Empty() { var scheduler = new TestScheduler(); @@ -319,7 +320,7 @@ public void Average_Double_Empty() ); } - [Fact] + [TestMethod] public void Average_Double_Return() { var scheduler = new TestScheduler(); @@ -344,7 +345,7 @@ public void Average_Double_Return() ); } - [Fact] + [TestMethod] public void Average_Double_Some() { var scheduler = new TestScheduler(); @@ -371,7 +372,7 @@ public void Average_Double_Some() ); } - [Fact] + [TestMethod] public void Average_Double_Throw() { var ex = new Exception(); @@ -396,7 +397,7 @@ public void Average_Double_Throw() ); } - [Fact] + [TestMethod] public void Average_Double_Never() { var ex = new Exception(); @@ -419,7 +420,7 @@ public void Average_Double_Never() ); } - [Fact] + [TestMethod] public void Average_Float_Empty() { var scheduler = new TestScheduler(); @@ -442,7 +443,7 @@ public void Average_Float_Empty() ); } - [Fact] + [TestMethod] public void Average_Float_Return() { var scheduler = new TestScheduler(); @@ -467,7 +468,7 @@ public void Average_Float_Return() ); } - [Fact] + [TestMethod] public void Average_Float_Some() { var scheduler = new TestScheduler(); @@ -494,7 +495,7 @@ public void Average_Float_Some() ); } - [Fact] + [TestMethod] public void Average_Float_Throw() { var ex = new Exception(); @@ -519,7 +520,7 @@ public void Average_Float_Throw() ); } - [Fact] + [TestMethod] public void Average_Float_Never() { var ex = new Exception(); @@ -542,7 +543,7 @@ public void Average_Float_Never() ); } - [Fact] + [TestMethod] public void Average_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -565,7 +566,7 @@ public void Average_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Average_Decimal_Return() { var scheduler = new TestScheduler(); @@ -590,7 +591,7 @@ public void Average_Decimal_Return() ); } - [Fact] + [TestMethod] public void Average_Decimal_Some() { var scheduler = new TestScheduler(); @@ -617,7 +618,7 @@ public void Average_Decimal_Some() ); } - [Fact] + [TestMethod] public void Average_Decimal_Throw() { var ex = new Exception(); @@ -642,7 +643,7 @@ public void Average_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Average_Decimal_Never() { var ex = new Exception(); @@ -665,7 +666,7 @@ public void Average_Decimal_Never() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int32_Empty() { var scheduler = new TestScheduler(); @@ -689,7 +690,7 @@ public void Average_Nullable_Int32_Empty() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int32_Return() { var scheduler = new TestScheduler(); @@ -714,7 +715,7 @@ public void Average_Nullable_Int32_Return() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int32_Some() { var scheduler = new TestScheduler(); @@ -741,7 +742,7 @@ public void Average_Nullable_Int32_Some() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int32_Throw() { var ex = new Exception(); @@ -766,7 +767,7 @@ public void Average_Nullable_Int32_Throw() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int32_Never() { var ex = new Exception(); @@ -789,7 +790,7 @@ public void Average_Nullable_Int32_Never() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int64_Empty() { var scheduler = new TestScheduler(); @@ -813,7 +814,7 @@ public void Average_Nullable_Int64_Empty() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int64_Return() { var scheduler = new TestScheduler(); @@ -838,7 +839,7 @@ public void Average_Nullable_Int64_Return() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int64_Some() { var scheduler = new TestScheduler(); @@ -865,7 +866,7 @@ public void Average_Nullable_Int64_Some() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int64_Throw() { var ex = new Exception(); @@ -890,7 +891,7 @@ public void Average_Nullable_Int64_Throw() ); } - [Fact] + [TestMethod] public void Average_Nullable_Int64_Never() { var ex = new Exception(); @@ -913,7 +914,7 @@ public void Average_Nullable_Int64_Never() ); } - [Fact] + [TestMethod] public void Average_Nullable_Double_Empty() { var scheduler = new TestScheduler(); @@ -937,7 +938,7 @@ public void Average_Nullable_Double_Empty() ); } - [Fact] + [TestMethod] public void Average_Nullable_Double_Return() { var scheduler = new TestScheduler(); @@ -962,7 +963,7 @@ public void Average_Nullable_Double_Return() ); } - [Fact] + [TestMethod] public void Average_Nullable_Double_Some() { var scheduler = new TestScheduler(); @@ -989,7 +990,7 @@ public void Average_Nullable_Double_Some() ); } - [Fact] + [TestMethod] public void Average_Nullable_Double_Throw() { var ex = new Exception(); @@ -1014,7 +1015,7 @@ public void Average_Nullable_Double_Throw() ); } - [Fact] + [TestMethod] public void Average_Nullable_Double_Never() { var ex = new Exception(); @@ -1037,7 +1038,7 @@ public void Average_Nullable_Double_Never() ); } - [Fact] + [TestMethod] public void Average_Nullable_Float_Empty() { var scheduler = new TestScheduler(); @@ -1061,7 +1062,7 @@ public void Average_Nullable_Float_Empty() ); } - [Fact] + [TestMethod] public void Average_Nullable_Float_Return() { var scheduler = new TestScheduler(); @@ -1086,7 +1087,7 @@ public void Average_Nullable_Float_Return() ); } - [Fact] + [TestMethod] public void Average_Nullable_Float_Some() { var scheduler = new TestScheduler(); @@ -1113,7 +1114,7 @@ public void Average_Nullable_Float_Some() ); } - [Fact] + [TestMethod] public void Average_Nullable_Float_Throw() { var ex = new Exception(); @@ -1138,7 +1139,7 @@ public void Average_Nullable_Float_Throw() ); } - [Fact] + [TestMethod] public void Average_Nullable_Float_Never() { var ex = new Exception(); @@ -1161,7 +1162,7 @@ public void Average_Nullable_Float_Never() ); } - [Fact] + [TestMethod] public void Average_Nullable_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -1185,7 +1186,7 @@ public void Average_Nullable_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Average_Nullable_Decimal_Return() { var scheduler = new TestScheduler(); @@ -1210,7 +1211,7 @@ public void Average_Nullable_Decimal_Return() ); } - [Fact] + [TestMethod] public void Average_Nullable_Decimal_Some() { var scheduler = new TestScheduler(); @@ -1237,7 +1238,7 @@ public void Average_Nullable_Decimal_Some() ); } - [Fact] + [TestMethod] public void Average_Nullable_Decimal_Throw() { var ex = new Exception(); @@ -1262,7 +1263,7 @@ public void Average_Nullable_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Average_Nullable_Decimal_Never() { var ex = new Exception(); @@ -1287,7 +1288,7 @@ public void Average_Nullable_Decimal_Never() #if !NO_PERF #if !NO_THREAD - [Fact] + [TestMethod] public void Average_InjectOverflow_Int32() { var xs = Observable.Return(42, ThreadPoolScheduler.Instance); @@ -1297,7 +1298,7 @@ public void Average_InjectOverflow_Int32() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Int64() { var xs = Observable.Return(42L, ThreadPoolScheduler.Instance); @@ -1307,7 +1308,7 @@ public void Average_InjectOverflow_Int64() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Double() { var xs = Observable.Return(42.0, ThreadPoolScheduler.Instance); @@ -1317,7 +1318,7 @@ public void Average_InjectOverflow_Double() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Single() { var xs = Observable.Return(42.0f, ThreadPoolScheduler.Instance); @@ -1327,7 +1328,7 @@ public void Average_InjectOverflow_Single() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Decimal() { var xs = Observable.Return(42.0m, ThreadPoolScheduler.Instance); @@ -1337,7 +1338,7 @@ public void Average_InjectOverflow_Decimal() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Int32_Nullable() { var xs = Observable.Return((int?)42, ThreadPoolScheduler.Instance); @@ -1347,7 +1348,7 @@ public void Average_InjectOverflow_Int32_Nullable() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Int64_Nullable() { var xs = Observable.Return((long?)42L, ThreadPoolScheduler.Instance); @@ -1357,7 +1358,7 @@ public void Average_InjectOverflow_Int64_Nullable() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Double_Nullable() { var xs = Observable.Return((double?)42.0, ThreadPoolScheduler.Instance); @@ -1367,7 +1368,7 @@ public void Average_InjectOverflow_Double_Nullable() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Single_Nullable() { var xs = Observable.Return((float?)42.0f, ThreadPoolScheduler.Instance); @@ -1377,7 +1378,7 @@ public void Average_InjectOverflow_Single_Nullable() ReactiveAssert.Throws(() => res.ForEach(_ => { })); } - [Fact] + [TestMethod] public void Average_InjectOverflow_Decimal_Nullable() { var xs = Observable.Return((decimal?)42.0m, ThreadPoolScheduler.Instance); @@ -1410,7 +1411,7 @@ public IDisposable Subscribe(IObserver observer) #endif #endif - [Fact] + [TestMethod] public void Average_Selector_Regular_Int32() { var scheduler = new TestScheduler(); @@ -1434,7 +1435,7 @@ public void Average_Selector_Regular_Int32() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Int64() { var scheduler = new TestScheduler(); @@ -1458,7 +1459,7 @@ public void Average_Selector_Regular_Int64() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Single() { var scheduler = new TestScheduler(); @@ -1482,7 +1483,7 @@ public void Average_Selector_Regular_Single() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Double() { var scheduler = new TestScheduler(); @@ -1506,7 +1507,7 @@ public void Average_Selector_Regular_Double() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Decimal() { var scheduler = new TestScheduler(); @@ -1530,7 +1531,7 @@ public void Average_Selector_Regular_Decimal() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Int32_Nullable() { var scheduler = new TestScheduler(); @@ -1554,7 +1555,7 @@ public void Average_Selector_Regular_Int32_Nullable() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Int64_Nullable() { var scheduler = new TestScheduler(); @@ -1578,7 +1579,7 @@ public void Average_Selector_Regular_Int64_Nullable() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Single_Nullable() { var scheduler = new TestScheduler(); @@ -1602,7 +1603,7 @@ public void Average_Selector_Regular_Single_Nullable() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Double_Nullable() { var scheduler = new TestScheduler(); @@ -1626,7 +1627,7 @@ public void Average_Selector_Regular_Double_Nullable() ); } - [Fact] + [TestMethod] public void Average_Selector_Regular_Decimal_Nullable() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AwaitTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AwaitTest.cs index a63a554f39..47ac00aa9e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AwaitTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/AwaitTest.cs @@ -9,13 +9,16 @@ 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(() => Observable.GetAwaiter(default(IObservable))); @@ -24,7 +27,7 @@ public void Await_ArgumentChecking() ReactiveAssert.Throws(() => Observable.GetAwaiter(Observable.Empty()).OnCompleted(null)); } - [Fact] + [TestMethod] public void Await() { SynchronizationContext.SetSynchronizationContext(null); @@ -57,7 +60,7 @@ public void Await() ); } - [Fact] + [TestMethod] public void Await_Connectable() { SynchronizationContext.SetSynchronizationContext(null); @@ -92,7 +95,7 @@ public void Await_Connectable() Assert.Equal(42, result); } - [Fact] + [TestMethod] public void Await_Error() { SynchronizationContext.SetSynchronizationContext(null); @@ -125,7 +128,7 @@ public void Await_Error() ); } - [Fact] + [TestMethod] public void Await_Never() { SynchronizationContext.SetSynchronizationContext(null); @@ -157,7 +160,7 @@ public void Await_Never() ); } - [Fact] + [TestMethod] public void Await_Empty() { SynchronizationContext.SetSynchronizationContext(null); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/BufferTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/BufferTest.cs index e23b860ea1..142882136b 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/BufferTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/BufferTest.cs @@ -9,15 +9,16 @@ 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(() => Observable.Buffer(default(IObservable), DummyFunc>.Instance)); @@ -29,7 +30,7 @@ public void Buffer_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Buffer(DummyObservable.Instance, default(IObservable))); } - [Fact] + [TestMethod] public void Buffer_Closings_Basic() { var scheduler = new TestScheduler(); @@ -66,7 +67,7 @@ public void Buffer_Closings_Basic() ); } - [Fact] + [TestMethod] public void Buffer_Closings_InnerSubscriptions() { var scheduler = new TestScheduler(); @@ -139,7 +140,7 @@ public void Buffer_Closings_InnerSubscriptions() ); } - [Fact] + [TestMethod] public void Buffer_Closings_Empty() { var scheduler = new TestScheduler(); @@ -177,7 +178,7 @@ public void Buffer_Closings_Empty() } - [Fact] + [TestMethod] public void Buffer_Closings_Dispose() { var scheduler = new TestScheduler(); @@ -212,7 +213,7 @@ public void Buffer_Closings_Dispose() ); } - [Fact] + [TestMethod] public void Buffer_Closings_Error() { var scheduler = new TestScheduler(); @@ -250,7 +251,7 @@ public void Buffer_Closings_Error() ); } - [Fact] + [TestMethod] public void Buffer_Closings_Throw() { var scheduler = new TestScheduler(); @@ -284,7 +285,7 @@ public void Buffer_Closings_Throw() ); } - [Fact] + [TestMethod] public void Buffer_Closings_WindowClose_Error() { var scheduler = new TestScheduler(); @@ -318,7 +319,7 @@ public void Buffer_Closings_WindowClose_Error() ); } - [Fact] + [TestMethod] public void Buffer_OpeningClosings_Basic() { var scheduler = new TestScheduler(); @@ -372,7 +373,7 @@ public void Buffer_OpeningClosings_Basic() ); } - [Fact] + [TestMethod] public void Buffer_Boundaries_Simple() { var scheduler = new TestScheduler(); @@ -423,7 +424,7 @@ public void Buffer_Boundaries_Simple() ); } - [Fact] + [TestMethod] public void Buffer_Boundaries_OnCompletedBoundaries() { var scheduler = new TestScheduler(); @@ -470,7 +471,7 @@ public void Buffer_Boundaries_OnCompletedBoundaries() ); } - [Fact] + [TestMethod] public void Buffer_Boundaries_OnErrorSource() { var ex = new Exception(); @@ -515,7 +516,7 @@ public void Buffer_Boundaries_OnErrorSource() ); } - [Fact] + [TestMethod] public void Buffer_Boundaries_OnErrorBoundaries() { var ex = new Exception(); @@ -567,7 +568,7 @@ public void Buffer_Boundaries_OnErrorBoundaries() #region + Count + - [Fact] + [TestMethod] public void Buffer_Single_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -580,7 +581,7 @@ public void Buffer_Single_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Buffer(someObservable, 0, 1)); } - [Fact] + [TestMethod] public void Buffer_Count_PartialWindow() { var scheduler = new TestScheduler(); @@ -608,7 +609,7 @@ public void Buffer_Count_PartialWindow() ); } - [Fact] + [TestMethod] public void Buffer_Count_FullWindows() { var scheduler = new TestScheduler(); @@ -637,7 +638,7 @@ public void Buffer_Count_FullWindows() ); } - [Fact] + [TestMethod] public void Buffer_Count_FullAndPartialWindows() { var scheduler = new TestScheduler(); @@ -666,7 +667,7 @@ public void Buffer_Count_FullAndPartialWindows() ); } - [Fact] + [TestMethod] public void Buffer_Count_Error() { var scheduler = new TestScheduler(); @@ -695,7 +696,7 @@ public void Buffer_Count_Error() ); } - [Fact] + [TestMethod] public void Buffer_Count_Skip_Less() { var scheduler = new TestScheduler(); @@ -726,7 +727,7 @@ public void Buffer_Count_Skip_Less() ); } - [Fact] + [TestMethod] public void Buffer_Count_Skip_More() { var scheduler = new TestScheduler(); @@ -755,7 +756,7 @@ public void Buffer_Count_Skip_More() ); } - [Fact] + [TestMethod] public void BufferWithCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Buffer(default(IObservable), 1, 1)); @@ -765,7 +766,7 @@ public void BufferWithCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Buffer(DummyObservable.Instance, 0)); } - [Fact] + [TestMethod] public void BufferWithCount_Basic() { var scheduler = new TestScheduler(); @@ -800,7 +801,7 @@ public void BufferWithCount_Basic() ); } - [Fact] + [TestMethod] public void BufferWithCount_Disposed() { var scheduler = new TestScheduler(); @@ -832,7 +833,7 @@ public void BufferWithCount_Disposed() ); } - [Fact] + [TestMethod] public void BufferWithCount_Error() { var scheduler = new TestScheduler(); @@ -868,7 +869,7 @@ public void BufferWithCount_Error() ); } - [Fact] + [TestMethod] public void BufferWithCount_Default() { Observable.Range(1, 10).Buffer(3).Skip(1).First().AssertEqual(4, 5, 6); @@ -879,7 +880,7 @@ public void BufferWithCount_Default() #region + Time + - [Fact] + [TestMethod] public void Buffer_Time_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -893,7 +894,7 @@ public void Buffer_Time_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Buffer(default(IObservable), TimeSpan.Zero, TimeSpan.Zero, scheduler)); } - [Fact] + [TestMethod] public void BufferWithTime_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Buffer(default(IObservable), TimeSpan.FromTicks(1), TimeSpan.FromTicks(1), DummyScheduler.Instance)); @@ -910,7 +911,7 @@ public void BufferWithTime_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Buffer(DummyObservable.Instance, TimeSpan.FromTicks(-1))); } - [Fact] + [TestMethod] public void BufferWithTime_Basic1() { var scheduler = new TestScheduler(); @@ -947,7 +948,7 @@ public void BufferWithTime_Basic1() ); } - [Fact] + [TestMethod] public void BufferWithTime_Basic2() { var scheduler = new TestScheduler(); @@ -982,7 +983,7 @@ public void BufferWithTime_Basic2() ); } - [Fact] + [TestMethod] public void BufferWithTime_Error() { var scheduler = new TestScheduler(); @@ -1020,7 +1021,7 @@ public void BufferWithTime_Error() ); } - [Fact] + [TestMethod] public void BufferWithTime_Disposed() { var scheduler = new TestScheduler(); @@ -1052,7 +1053,7 @@ public void BufferWithTime_Disposed() ); } - [Fact] + [TestMethod] public void BufferWithTime_Basic_Same() { var scheduler = new TestScheduler(); @@ -1087,7 +1088,7 @@ public void BufferWithTime_Basic_Same() ); } - [Fact] + [TestMethod] public void BufferWithTime_Basic_Same_Periodic() { var scheduler = new PeriodicTestScheduler(); @@ -1128,7 +1129,7 @@ public void BufferWithTime_Basic_Same_Periodic() #endif } - [Fact] + [TestMethod] public void BufferWithTime_Basic_Same_Periodic_Error() { var ex = new Exception(); @@ -1169,14 +1170,14 @@ public void BufferWithTime_Basic_Same_Periodic_Error() #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(() => Observable.Buffer(default(IObservable), TimeSpan.FromTicks(1), 1, DummyScheduler.Instance)); @@ -1188,7 +1189,7 @@ public void BufferWithTimeOrCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Buffer(DummyObservable.Instance, TimeSpan.FromTicks(1), 0)); } - [Fact] + [TestMethod] public void BufferWithTimeOrCount_Basic() { var scheduler = new TestScheduler(); @@ -1226,7 +1227,7 @@ public void BufferWithTimeOrCount_Basic() ); } - [Fact] + [TestMethod] public void BufferWithTimeOrCount_Error() { var scheduler = new TestScheduler(); @@ -1265,7 +1266,7 @@ public void BufferWithTimeOrCount_Error() ); } - [Fact] + [TestMethod] public void BufferWithTimeOrCount_Disposed() { var scheduler = new TestScheduler(); @@ -1299,13 +1300,13 @@ public void BufferWithTimeOrCount_Disposed() ); } - [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(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CaseTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CaseTest.cs index 4b9837118b..f2181fbb7e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CaseTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CaseTest.cs @@ -8,14 +8,15 @@ 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(() => Observable.Case(null, new Dictionary>(), DummyObservable.Instance)); @@ -30,7 +31,7 @@ public void Case_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Case(DummyFunc.Instance, null)); } - [Fact] + [TestMethod] public void Case_One() { var scheduler = new TestScheduler(); @@ -82,7 +83,7 @@ public void Case_One() ); } - [Fact] + [TestMethod] public void Case_Two() { var scheduler = new TestScheduler(); @@ -134,7 +135,7 @@ public void Case_Two() ); } - [Fact] + [TestMethod] public void Case_Three() { var scheduler = new TestScheduler(); @@ -186,7 +187,7 @@ public void Case_Three() ); } - [Fact] + [TestMethod] public void Case_Throw() { var scheduler = new TestScheduler(); @@ -236,7 +237,7 @@ public void Case_Throw() ); } - [Fact] + [TestMethod] public void CaseWithDefault_One() { var scheduler = new TestScheduler(); @@ -278,7 +279,7 @@ public void CaseWithDefault_One() ); } - [Fact] + [TestMethod] public void CaseWithDefault_Two() { var scheduler = new TestScheduler(); @@ -320,7 +321,7 @@ public void CaseWithDefault_Two() ); } - [Fact] + [TestMethod] public void CaseWithDefault_Three() { var scheduler = new TestScheduler(); @@ -358,7 +359,7 @@ public void CaseWithDefault_Three() ); } - [Fact] + [TestMethod] public void CaseWithDefault_Throw() { var scheduler = new TestScheduler(); @@ -398,14 +399,14 @@ public void CaseWithDefault_Throw() ); } - [Fact] + [TestMethod] public void CaseWithDefault_CheckDefault() { Observable.Case(() => 1, new Dictionary>(), DefaultScheduler.Instance) .AssertEqual(Observable.Case(() => 1, new Dictionary>())); } - [Fact] + [TestMethod] public void Case_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CastTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CastTest.cs index e3f2dd5790..63d27ca5e3 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CastTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CastTest.cs @@ -7,21 +7,22 @@ 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(() => Observable.Cast(default)); ReactiveAssert.Throws(() => Observable.Cast(DummyObservable.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Cast_Complete() { var scheduler = new TestScheduler(); @@ -51,7 +52,7 @@ public void Cast_Complete() ); } - [Fact] + [TestMethod] public void Cast_Error() { var scheduler = new TestScheduler(); @@ -83,7 +84,7 @@ public void Cast_Error() ); } - [Fact] + [TestMethod] public void Cast_Dispose() { var scheduler = new TestScheduler(); @@ -112,7 +113,7 @@ public void Cast_Dispose() ); } - [Fact] + [TestMethod] public void Cast_NotValid() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CatchTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CatchTest.cs index b9c8042d59..31d912bc4c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CatchTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CatchTest.cs @@ -11,14 +11,17 @@ 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(() => Observable.Catch(null)); @@ -29,7 +32,7 @@ public void Catch_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Catch(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void Catch_IEofIO_GetEnumeratorThrows() { var ex = new Exception(); @@ -47,7 +50,7 @@ public void Catch_IEofIO_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void Catch_IEofIO() { var scheduler = new TestScheduler(); @@ -103,7 +106,7 @@ public void Catch_IEofIO() ); } - [Fact] + [TestMethod] public void Catch_NoErrors() { var scheduler = new TestScheduler(); @@ -138,7 +141,7 @@ public void Catch_NoErrors() ); } - [Fact] + [TestMethod] public void Catch_Never() { var scheduler = new TestScheduler(); @@ -167,7 +170,7 @@ public void Catch_Never() ); } - [Fact] + [TestMethod] public void Catch_Empty() { var scheduler = new TestScheduler(); @@ -198,7 +201,7 @@ public void Catch_Empty() ); } - [Fact] + [TestMethod] public void Catch_Return() { var scheduler = new TestScheduler(); @@ -231,7 +234,7 @@ public void Catch_Return() ); } - [Fact] + [TestMethod] public void Catch_Error() { var scheduler = new TestScheduler(); @@ -270,7 +273,7 @@ public void Catch_Error() ); } - [Fact] + [TestMethod] public void Catch_Error_Never() { var scheduler = new TestScheduler(); @@ -306,7 +309,7 @@ public void Catch_Error_Never() ); } - [Fact] + [TestMethod] public void Catch_Error_Error() { var scheduler = new TestScheduler(); @@ -345,7 +348,7 @@ public void Catch_Error_Error() ); } - [Fact] + [TestMethod] public void Catch_Multiple() { var scheduler = new TestScheduler(); @@ -392,7 +395,7 @@ public void Catch_Multiple() ); } - [Fact] + [TestMethod] public void Catch_ErrorSpecific_Caught() { var scheduler = new TestScheduler(); @@ -435,7 +438,7 @@ public void Catch_ErrorSpecific_Caught() ); } - [Fact] + [TestMethod] public void Catch_ErrorSpecific_Uncaught() { var scheduler = new TestScheduler(); @@ -476,7 +479,7 @@ public void Catch_ErrorSpecific_Uncaught() ); } - [Fact] + [TestMethod] public void Catch_HandlerThrows() { var scheduler = new TestScheduler(); @@ -510,7 +513,7 @@ public void Catch_HandlerThrows() ); } - [Fact] + [TestMethod] public void Catch_Nested_OuterCatches() { var scheduler = new TestScheduler(); @@ -563,7 +566,7 @@ public void Catch_Nested_OuterCatches() ); } - [Fact] + [TestMethod] public void Catch_Nested_InnerCatches() { var scheduler = new TestScheduler(); @@ -616,7 +619,7 @@ public void Catch_Nested_InnerCatches() ); } - [Fact] + [TestMethod] public void Catch_ThrowFromNestedCatch() { var scheduler = new TestScheduler(); @@ -672,7 +675,7 @@ public void Catch_ThrowFromNestedCatch() ); } - [Fact] + [TestMethod] public void Catch_DefaultScheduler_Binary() { var evt = new ManualResetEvent(false); @@ -688,7 +691,7 @@ public void Catch_DefaultScheduler_Binary() Assert.Equal(1, res); } - [Fact] + [TestMethod] public void Catch_DefaultScheduler_Nary() { var evt = new ManualResetEvent(false); @@ -704,7 +707,7 @@ public void Catch_DefaultScheduler_Nary() Assert.Equal(1, res); } - [Fact] + [TestMethod] public void Catch_DefaultScheduler_NaryEnumerable() { var evt = new ManualResetEvent(false); @@ -722,7 +725,7 @@ public void Catch_DefaultScheduler_NaryEnumerable() Assert.Equal(1, res); } - [Fact] + [TestMethod] public void Catch_EmptyIterator() { var scheduler = new TestScheduler(); @@ -736,7 +739,7 @@ public void Catch_EmptyIterator() ); } - [Fact] + [TestMethod] public void Catch_IteratorThrows() { var scheduler = new TestScheduler(); @@ -763,7 +766,7 @@ private IEnumerable> Catch_IteratorThrows_Source(Exception ex, } } - [Fact] + [TestMethod] public void Catch_EnumerableThrows() { var scheduler = new TestScheduler(); @@ -803,7 +806,7 @@ private IEnumerable> GetObservablesForCatchThrow(IObservable>); @@ -969,7 +972,7 @@ public void Catch_TailRecursive2() } #endif - [Fact] + [TestMethod] public void Catch_TailRecursive3() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ChunkifyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ChunkifyTest.cs index 12add0e355..c0cb483878 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ChunkifyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ChunkifyTest.cs @@ -8,20 +8,23 @@ 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(() => Observable.Chunkify(default(IObservable))); } - [Fact] + [TestMethod] public void Chunkify_Regular1() { var scheduler = new TestScheduler(); @@ -75,7 +78,7 @@ public void Chunkify_Regular1() Assert.True(res[6].SequenceEqual(new int[] { })); } - [Fact] + [TestMethod] public void Chunkify_Regular2() { var scheduler = new TestScheduler(); @@ -119,7 +122,7 @@ public void Chunkify_Regular2() Assert.True(res[1].SequenceEqual(new int[] { 6, 7, 8 })); } - [Fact] + [TestMethod] public void Chunkify_Error() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CollectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CollectTest.cs index 854a335e8e..a240ee1d5a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CollectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CollectTest.cs @@ -8,14 +8,17 @@ 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(); @@ -30,7 +33,7 @@ public void Collect_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Collect(someObservable, () => 0, (x, y) => x, default)); } - [Fact] + [TestMethod] public void Collect_Regular1() { var scheduler = new TestScheduler(); @@ -84,7 +87,7 @@ public void Collect_Regular1() Assert.Equal(res[6], new int[] { }.Sum()); } - [Fact] + [TestMethod] public void Collect_Regular2() { var scheduler = new TestScheduler(); @@ -128,7 +131,7 @@ public void Collect_Regular2() Assert.Equal(res[1], new int[] { 6, 7, 8 }.Sum()); } - [Fact] + [TestMethod] public void Collect_InitialCollectorThrows() { var scheduler = new TestScheduler(); @@ -166,7 +169,7 @@ public void Collect_InitialCollectorThrows() Assert.Same(ex_, ex); } - [Fact] + [TestMethod] public void Collect_SecondCollectorThrows() { var scheduler = new TestScheduler(); @@ -218,7 +221,7 @@ public void Collect_SecondCollectorThrows() Assert.Same(ex_, ex); } - [Fact] + [TestMethod] public void Collect_NewCollectorThrows() { var scheduler = new TestScheduler(); @@ -259,7 +262,7 @@ public void Collect_NewCollectorThrows() Assert.Same(ex_, ex); } - [Fact] + [TestMethod] public void Collect_MergeThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CombineLatestTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CombineLatestTest.cs index 54707b1e7f..3897feaf70 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CombineLatestTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CombineLatestTest.cs @@ -8,17 +8,18 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { #pragma warning disable IDE0039 // Use local function + [TestClass] public class CombineLatestTest : ReactiveTest { #region ArgumentChecking - [Fact] + [TestMethod] public void CombineLatest_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.CombineLatest(DummyObservable.Instance, DummyObservable.Instance, null)); @@ -26,7 +27,7 @@ public void CombineLatest_ArgumentChecking() ReactiveAssert.Throws(() => Observable.CombineLatest(DummyObservable.Instance, null, (_, __) => 0)); } - [Fact] + [TestMethod] public void CombineLatest_ArgumentCheckingHighArity() { var xs = DummyObservable.Instance; @@ -187,7 +188,7 @@ public void CombineLatest_ArgumentCheckingHighArity() #region Never - [Fact] + [TestMethod] public void CombineLatest_NeverN() { var scheduler = new TestScheduler(); @@ -209,7 +210,7 @@ public void CombineLatest_NeverN() } } - [Fact] + [TestMethod] public void CombineLatest_Never2() { var scheduler = new TestScheduler(); @@ -230,7 +231,7 @@ public void CombineLatest_Never2() } } - [Fact] + [TestMethod] public void CombineLatest_Never3() { var scheduler = new TestScheduler(); @@ -252,7 +253,7 @@ public void CombineLatest_Never3() } } - [Fact] + [TestMethod] public void CombineLatest_Never4() { var scheduler = new TestScheduler(); @@ -275,7 +276,7 @@ public void CombineLatest_Never4() } } - [Fact] + [TestMethod] public void CombineLatest_Never5() { var scheduler = new TestScheduler(); @@ -299,7 +300,7 @@ public void CombineLatest_Never5() } } - [Fact] + [TestMethod] public void CombineLatest_Never6() { var scheduler = new TestScheduler(); @@ -324,7 +325,7 @@ public void CombineLatest_Never6() } } - [Fact] + [TestMethod] public void CombineLatest_Never7() { var scheduler = new TestScheduler(); @@ -350,7 +351,7 @@ public void CombineLatest_Never7() } } - [Fact] + [TestMethod] public void CombineLatest_Never8() { var scheduler = new TestScheduler(); @@ -377,7 +378,7 @@ public void CombineLatest_Never8() } } - [Fact] + [TestMethod] public void CombineLatest_Never9() { var scheduler = new TestScheduler(); @@ -405,7 +406,7 @@ public void CombineLatest_Never9() } } - [Fact] + [TestMethod] public void CombineLatest_Never10() { var scheduler = new TestScheduler(); @@ -434,7 +435,7 @@ public void CombineLatest_Never10() } } - [Fact] + [TestMethod] public void CombineLatest_Never11() { var scheduler = new TestScheduler(); @@ -464,7 +465,7 @@ public void CombineLatest_Never11() } } - [Fact] + [TestMethod] public void CombineLatest_Never12() { var scheduler = new TestScheduler(); @@ -495,7 +496,7 @@ public void CombineLatest_Never12() } } - [Fact] + [TestMethod] public void CombineLatest_Never13() { var scheduler = new TestScheduler(); @@ -527,7 +528,7 @@ public void CombineLatest_Never13() } } - [Fact] + [TestMethod] public void CombineLatest_Never14() { var scheduler = new TestScheduler(); @@ -560,7 +561,7 @@ public void CombineLatest_Never14() } } - [Fact] + [TestMethod] public void CombineLatest_Never15() { var scheduler = new TestScheduler(); @@ -594,7 +595,7 @@ public void CombineLatest_Never15() } } - [Fact] + [TestMethod] public void CombineLatest_Never16() { var scheduler = new TestScheduler(); @@ -633,7 +634,7 @@ public void CombineLatest_Never16() #region Never/Empty - [Fact] + [TestMethod] public void CombineLatest_NeverEmpty() { var scheduler = new TestScheduler(); @@ -663,7 +664,7 @@ public void CombineLatest_NeverEmpty() ); } - [Fact] + [TestMethod] public void CombineLatest_EmptyNever() { var scheduler = new TestScheduler(); @@ -697,7 +698,7 @@ public void CombineLatest_EmptyNever() #region Empty - [Fact] + [TestMethod] public void CombineLatest_EmptyN() { var scheduler = new TestScheduler(); @@ -721,7 +722,7 @@ public void CombineLatest_EmptyN() } } - [Fact] + [TestMethod] public void CombineLatest_Empty2() { var scheduler = new TestScheduler(); @@ -744,7 +745,7 @@ public void CombineLatest_Empty2() } } - [Fact] + [TestMethod] public void CombineLatest_Empty3() { var scheduler = new TestScheduler(); @@ -768,7 +769,7 @@ public void CombineLatest_Empty3() } } - [Fact] + [TestMethod] public void CombineLatest_Empty4() { var scheduler = new TestScheduler(); @@ -793,7 +794,7 @@ public void CombineLatest_Empty4() } } - [Fact] + [TestMethod] public void CombineLatest_Empty5() { var scheduler = new TestScheduler(); @@ -819,7 +820,7 @@ public void CombineLatest_Empty5() } } - [Fact] + [TestMethod] public void CombineLatest_Empty6() { var scheduler = new TestScheduler(); @@ -846,7 +847,7 @@ public void CombineLatest_Empty6() } } - [Fact] + [TestMethod] public void CombineLatest_Empty7() { var scheduler = new TestScheduler(); @@ -874,7 +875,7 @@ public void CombineLatest_Empty7() } } - [Fact] + [TestMethod] public void CombineLatest_Empty8() { var scheduler = new TestScheduler(); @@ -903,7 +904,7 @@ public void CombineLatest_Empty8() } } - [Fact] + [TestMethod] public void CombineLatest_Empty9() { var scheduler = new TestScheduler(); @@ -933,7 +934,7 @@ public void CombineLatest_Empty9() } } - [Fact] + [TestMethod] public void CombineLatest_Empty10() { var scheduler = new TestScheduler(); @@ -964,7 +965,7 @@ public void CombineLatest_Empty10() } } - [Fact] + [TestMethod] public void CombineLatest_Empty11() { var scheduler = new TestScheduler(); @@ -996,7 +997,7 @@ public void CombineLatest_Empty11() } } - [Fact] + [TestMethod] public void CombineLatest_Empty12() { var scheduler = new TestScheduler(); @@ -1029,7 +1030,7 @@ public void CombineLatest_Empty12() } } - [Fact] + [TestMethod] public void CombineLatest_Empty13() { var scheduler = new TestScheduler(); @@ -1063,7 +1064,7 @@ public void CombineLatest_Empty13() } } - [Fact] + [TestMethod] public void CombineLatest_Empty14() { var scheduler = new TestScheduler(); @@ -1098,7 +1099,7 @@ public void CombineLatest_Empty14() } } - [Fact] + [TestMethod] public void CombineLatest_Empty15() { var scheduler = new TestScheduler(); @@ -1134,7 +1135,7 @@ public void CombineLatest_Empty15() } } - [Fact] + [TestMethod] public void CombineLatest_Empty16() { var scheduler = new TestScheduler(); @@ -1175,7 +1176,7 @@ public void CombineLatest_Empty16() #region Empty/Return - [Fact] + [TestMethod] public void CombineLatest_EmptyReturn() { var scheduler = new TestScheduler(); @@ -1208,7 +1209,7 @@ public void CombineLatest_EmptyReturn() ); } - [Fact] + [TestMethod] public void CombineLatest_ReturnEmpty() { var scheduler = new TestScheduler(); @@ -1245,7 +1246,7 @@ public void CombineLatest_ReturnEmpty() #region Never/Return - [Fact] + [TestMethod] public void CombineLatest_NeverReturn() { var scheduler = new TestScheduler(); @@ -1276,7 +1277,7 @@ public void CombineLatest_NeverReturn() ); } - [Fact] + [TestMethod] public void CombineLatest_ReturnNever() { var scheduler = new TestScheduler(); @@ -1311,7 +1312,7 @@ public void CombineLatest_ReturnNever() #region Return/Return - [Fact] + [TestMethod] public void CombineLatest_ReturnReturn() { var scheduler = new TestScheduler(); @@ -1350,7 +1351,7 @@ public void CombineLatest_ReturnReturn() #region Empty/Error - [Fact] + [TestMethod] public void CombineLatest_EmptyError() { var scheduler = new TestScheduler(); @@ -1384,7 +1385,7 @@ public void CombineLatest_EmptyError() ); } - [Fact] + [TestMethod] public void CombineLatest_ErrorEmpty() { var scheduler = new TestScheduler(); @@ -1422,7 +1423,7 @@ public void CombineLatest_ErrorEmpty() #region Return/Throw - [Fact] + [TestMethod] public void CombineLatest_ReturnThrow() { var scheduler = new TestScheduler(); @@ -1457,7 +1458,7 @@ public void CombineLatest_ReturnThrow() ); } - [Fact] + [TestMethod] public void CombineLatest_ThrowReturn() { var scheduler = new TestScheduler(); @@ -1496,7 +1497,7 @@ public void CombineLatest_ThrowReturn() #region Throw/Throw - [Fact] + [TestMethod] public void CombineLatest_ThrowThrow() { var scheduler = new TestScheduler(); @@ -1531,7 +1532,7 @@ public void CombineLatest_ThrowThrow() ); } - [Fact] + [TestMethod] public void CombineLatest_ErrorThrow() { var scheduler = new TestScheduler(); @@ -1567,7 +1568,7 @@ public void CombineLatest_ErrorThrow() ); } - [Fact] + [TestMethod] public void CombineLatest_ThrowError() { var scheduler = new TestScheduler(); @@ -1607,7 +1608,7 @@ public void CombineLatest_ThrowError() #region Never/Throw - [Fact] + [TestMethod] public void CombineLatest_NeverThrow() { var scheduler = new TestScheduler(); @@ -1640,7 +1641,7 @@ public void CombineLatest_NeverThrow() ); } - [Fact] + [TestMethod] public void CombineLatest_ThrowNever() { var scheduler = new TestScheduler(); @@ -1677,7 +1678,7 @@ public void CombineLatest_ThrowNever() #region Some/Throw - [Fact] + [TestMethod] public void CombineLatest_SomeThrow() { var scheduler = new TestScheduler(); @@ -1712,7 +1713,7 @@ public void CombineLatest_SomeThrow() ); } - [Fact] + [TestMethod] public void CombineLatest_ThrowSome() { var scheduler = new TestScheduler(); @@ -1751,7 +1752,7 @@ public void CombineLatest_ThrowSome() #region ThrowAfterCompleted - [Fact] + [TestMethod] public void CombineLatest_ThrowAfterCompleteLeft() { var scheduler = new TestScheduler(); @@ -1786,7 +1787,7 @@ public void CombineLatest_ThrowAfterCompleteLeft() ); } - [Fact] + [TestMethod] public void CombineLatest_ThrowAfterCompleteRight() { var scheduler = new TestScheduler(); @@ -1825,7 +1826,7 @@ public void CombineLatest_ThrowAfterCompleteRight() #region Basics - [Fact] + [TestMethod] public void CombineLatest_InterleavedWithTail() { var scheduler = new TestScheduler(); @@ -1868,7 +1869,7 @@ public void CombineLatest_InterleavedWithTail() ); } - [Fact] + [TestMethod] public void CombineLatest_Consecutive() { var scheduler = new TestScheduler(); @@ -1906,7 +1907,7 @@ public void CombineLatest_Consecutive() ); } - [Fact] + [TestMethod] public void CombineLatest_ConsecutiveEndWithErrorLeft() { var scheduler = new TestScheduler(); @@ -1944,7 +1945,7 @@ public void CombineLatest_ConsecutiveEndWithErrorLeft() ); } - [Fact] + [TestMethod] public void CombineLatest_ConsecutiveEndWithErrorRight() { var scheduler = new TestScheduler(); @@ -1988,7 +1989,7 @@ public void CombineLatest_ConsecutiveEndWithErrorRight() #region SelectorThrows - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows() { var scheduler = new TestScheduler(); @@ -2024,7 +2025,7 @@ public void CombineLatest_SelectorThrows() ); } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrowsN() { var scheduler = new TestScheduler(); @@ -2051,7 +2052,7 @@ public void CombineLatest_SelectorThrowsN() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows2() { var scheduler = new TestScheduler(); @@ -2077,7 +2078,7 @@ public void CombineLatest_SelectorThrows2() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows3() { var scheduler = new TestScheduler(); @@ -2104,7 +2105,7 @@ public void CombineLatest_SelectorThrows3() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows4() { var scheduler = new TestScheduler(); @@ -2132,7 +2133,7 @@ public void CombineLatest_SelectorThrows4() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows5() { var scheduler = new TestScheduler(); @@ -2161,7 +2162,7 @@ public void CombineLatest_SelectorThrows5() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows6() { var scheduler = new TestScheduler(); @@ -2191,7 +2192,7 @@ public void CombineLatest_SelectorThrows6() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows7() { var scheduler = new TestScheduler(); @@ -2222,7 +2223,7 @@ public void CombineLatest_SelectorThrows7() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows8() { var scheduler = new TestScheduler(); @@ -2254,7 +2255,7 @@ public void CombineLatest_SelectorThrows8() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows9() { var scheduler = new TestScheduler(); @@ -2287,7 +2288,7 @@ public void CombineLatest_SelectorThrows9() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows10() { var scheduler = new TestScheduler(); @@ -2321,7 +2322,7 @@ public void CombineLatest_SelectorThrows10() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows11() { var scheduler = new TestScheduler(); @@ -2356,7 +2357,7 @@ public void CombineLatest_SelectorThrows11() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows12() { var scheduler = new TestScheduler(); @@ -2392,7 +2393,7 @@ public void CombineLatest_SelectorThrows12() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows13() { var scheduler = new TestScheduler(); @@ -2429,7 +2430,7 @@ public void CombineLatest_SelectorThrows13() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows14() { var scheduler = new TestScheduler(); @@ -2467,7 +2468,7 @@ public void CombineLatest_SelectorThrows14() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows15() { var scheduler = new TestScheduler(); @@ -2506,7 +2507,7 @@ public void CombineLatest_SelectorThrows15() } } - [Fact] + [TestMethod] public void CombineLatest_SelectorThrows16() { var scheduler = new TestScheduler(); @@ -2550,7 +2551,7 @@ public void CombineLatest_SelectorThrows16() #region AllEmptyButOne - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombineN() { var scheduler = new TestScheduler(); @@ -2577,7 +2578,7 @@ public void CombineLatest_WillNeverBeAbleToCombineN() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine2() { var scheduler = new TestScheduler(); @@ -2603,7 +2604,7 @@ public void CombineLatest_WillNeverBeAbleToCombine2() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine3() { var scheduler = new TestScheduler(); @@ -2630,7 +2631,7 @@ public void CombineLatest_WillNeverBeAbleToCombine3() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine4() { var scheduler = new TestScheduler(); @@ -2658,7 +2659,7 @@ public void CombineLatest_WillNeverBeAbleToCombine4() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine5() { var scheduler = new TestScheduler(); @@ -2687,7 +2688,7 @@ public void CombineLatest_WillNeverBeAbleToCombine5() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine6() { var scheduler = new TestScheduler(); @@ -2717,7 +2718,7 @@ public void CombineLatest_WillNeverBeAbleToCombine6() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine7() { var scheduler = new TestScheduler(); @@ -2748,7 +2749,7 @@ public void CombineLatest_WillNeverBeAbleToCombine7() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine8() { var scheduler = new TestScheduler(); @@ -2780,7 +2781,7 @@ public void CombineLatest_WillNeverBeAbleToCombine8() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine9() { var scheduler = new TestScheduler(); @@ -2813,7 +2814,7 @@ public void CombineLatest_WillNeverBeAbleToCombine9() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine10() { var scheduler = new TestScheduler(); @@ -2847,7 +2848,7 @@ public void CombineLatest_WillNeverBeAbleToCombine10() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine11() { var scheduler = new TestScheduler(); @@ -2882,7 +2883,7 @@ public void CombineLatest_WillNeverBeAbleToCombine11() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine12() { var scheduler = new TestScheduler(); @@ -2918,7 +2919,7 @@ public void CombineLatest_WillNeverBeAbleToCombine12() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine13() { var scheduler = new TestScheduler(); @@ -2955,7 +2956,7 @@ public void CombineLatest_WillNeverBeAbleToCombine13() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine14() { var scheduler = new TestScheduler(); @@ -2993,7 +2994,7 @@ public void CombineLatest_WillNeverBeAbleToCombine14() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine15() { var scheduler = new TestScheduler(); @@ -3032,7 +3033,7 @@ public void CombineLatest_WillNeverBeAbleToCombine15() es.Last().Subscriptions.AssertEqual(Subscribe(200, 500)); } - [Fact] + [TestMethod] public void CombineLatest_WillNeverBeAbleToCombine16() { var scheduler = new TestScheduler(); @@ -3076,7 +3077,7 @@ public void CombineLatest_WillNeverBeAbleToCombine16() #region Typical - [Fact] + [TestMethod] public void CombineLatest_TypicalN() { var scheduler = new TestScheduler(); @@ -3103,7 +3104,7 @@ public void CombineLatest_TypicalN() } } - [Fact] + [TestMethod] public void CombineLatest_Typical2() { var scheduler = new TestScheduler(); @@ -3128,7 +3129,7 @@ public void CombineLatest_Typical2() } } - [Fact] + [TestMethod] public void CombineLatest_Typical3() { var scheduler = new TestScheduler(); @@ -3155,7 +3156,7 @@ public void CombineLatest_Typical3() } } - [Fact] + [TestMethod] public void CombineLatest_Typical4() { var scheduler = new TestScheduler(); @@ -3184,7 +3185,7 @@ public void CombineLatest_Typical4() } } - [Fact] + [TestMethod] public void CombineLatest_Typical5() { var scheduler = new TestScheduler(); @@ -3215,7 +3216,7 @@ public void CombineLatest_Typical5() } } - [Fact] + [TestMethod] public void CombineLatest_Typical6() { var scheduler = new TestScheduler(); @@ -3248,7 +3249,7 @@ public void CombineLatest_Typical6() } } - [Fact] + [TestMethod] public void CombineLatest_Typical7() { var scheduler = new TestScheduler(); @@ -3283,7 +3284,7 @@ public void CombineLatest_Typical7() } } - [Fact] + [TestMethod] public void CombineLatest_Typical8() { var scheduler = new TestScheduler(); @@ -3320,7 +3321,7 @@ public void CombineLatest_Typical8() } } - [Fact] + [TestMethod] public void CombineLatest_Typical9() { var scheduler = new TestScheduler(); @@ -3359,7 +3360,7 @@ public void CombineLatest_Typical9() } } - [Fact] + [TestMethod] public void CombineLatest_Typical10() { var scheduler = new TestScheduler(); @@ -3400,7 +3401,7 @@ public void CombineLatest_Typical10() } } - [Fact] + [TestMethod] public void CombineLatest_Typical11() { var scheduler = new TestScheduler(); @@ -3443,7 +3444,7 @@ public void CombineLatest_Typical11() } } - [Fact] + [TestMethod] public void CombineLatest_Typical12() { var scheduler = new TestScheduler(); @@ -3488,7 +3489,7 @@ public void CombineLatest_Typical12() } } - [Fact] + [TestMethod] public void CombineLatest_Typical13() { var scheduler = new TestScheduler(); @@ -3535,7 +3536,7 @@ public void CombineLatest_Typical13() } } - [Fact] + [TestMethod] public void CombineLatest_Typical14() { var scheduler = new TestScheduler(); @@ -3584,7 +3585,7 @@ public void CombineLatest_Typical14() } } - [Fact] + [TestMethod] public void CombineLatest_Typical15() { var scheduler = new TestScheduler(); @@ -3635,7 +3636,7 @@ public void CombineLatest_Typical15() } } - [Fact] + [TestMethod] public void CombineLatest_Typical16() { var scheduler = new TestScheduler(); @@ -3692,7 +3693,7 @@ public void CombineLatest_Typical16() #region NAry - [Fact] + [TestMethod] public void CombineLatest_List_Regular() { var scheduler = new TestScheduler(); @@ -3714,7 +3715,7 @@ public void CombineLatest_List_Regular() ); } - [Fact] + [TestMethod] public void CombineLatest_NAry_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.CombineLatest(default(IEnumerable>))); @@ -3723,7 +3724,7 @@ public void CombineLatest_NAry_ArgumentChecking() ReactiveAssert.Throws(() => Observable.CombineLatest(default(IObservable[]))); } - [Fact] + [TestMethod] public void CombineLatest_NAry_Symmetric() { var scheduler = new TestScheduler(); @@ -3757,7 +3758,7 @@ public void CombineLatest_NAry_Symmetric() ); } - [Fact] + [TestMethod] public void CombineLatest_NAry_Symmetric_Selector() { var scheduler = new TestScheduler(); @@ -3791,7 +3792,7 @@ public void CombineLatest_NAry_Symmetric_Selector() ); } - [Fact] + [TestMethod] public void CombineLatest_NAry_Asymmetric() { var scheduler = new TestScheduler(); @@ -3828,7 +3829,7 @@ public void CombineLatest_NAry_Asymmetric() ); } - [Fact] + [TestMethod] public void CombineLatest_NAry_Asymmetric_Selector() { var scheduler = new TestScheduler(); @@ -3865,7 +3866,7 @@ public void CombineLatest_NAry_Asymmetric_Selector() ); } - [Fact] + [TestMethod] public void CombineLatest_NAry_Error() { var ex = new Exception(); @@ -3899,7 +3900,7 @@ public void CombineLatest_NAry_Error() ); } - [Fact] + [TestMethod] public void CombineLatest_NAry_Error_Selector() { var ex = new Exception(); @@ -3937,7 +3938,7 @@ public void CombineLatest_NAry_Error_Selector() #region AtLeastOneThrows - [Fact] + [TestMethod] public void CombineLatest_AtLeastOneThrows4() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ConcatTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ConcatTest.cs index dd50c34214..9ab94b8aa6 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ConcatTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ConcatTest.cs @@ -13,14 +13,17 @@ 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.Instance; @@ -35,7 +38,7 @@ public void Concat_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Concat(null, xs)); } - [Fact] + [TestMethod] public void Concat_DefaultScheduler() { var evt = new ManualResetEvent(false); @@ -51,7 +54,7 @@ public void Concat_DefaultScheduler() Assert.Equal(6, sum); } - [Fact] + [TestMethod] public void Concat_IEofIO_DefaultScheduler() { var evt = new ManualResetEvent(false); @@ -69,7 +72,7 @@ public void Concat_IEofIO_DefaultScheduler() Assert.Equal(6, sum); } - [Fact] + [TestMethod] public void Concat_IEofIO_GetEnumeratorThrows() { var ex = new Exception(); @@ -87,7 +90,7 @@ public void Concat_IEofIO_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void Concat_IEofIO() { var scheduler = new TestScheduler(); @@ -143,7 +146,7 @@ public void Concat_IEofIO() ); } - [Fact] + [TestMethod] public void Concat_EmptyEmpty() { var scheduler = new TestScheduler(); @@ -175,7 +178,7 @@ public void Concat_EmptyEmpty() ); } - [Fact] + [TestMethod] public void Concat_EmptyNever() { var scheduler = new TestScheduler(); @@ -205,7 +208,7 @@ public void Concat_EmptyNever() ); } - [Fact] + [TestMethod] public void Concat_NeverEmpty() { var scheduler = new TestScheduler(); @@ -234,7 +237,7 @@ public void Concat_NeverEmpty() ); } - [Fact] + [TestMethod] public void Concat_NeverNever() { var scheduler = new TestScheduler(); @@ -262,7 +265,7 @@ public void Concat_NeverNever() ); } - [Fact] + [TestMethod] public void Concat_EmptyThrow() { var scheduler = new TestScheduler(); @@ -296,7 +299,7 @@ public void Concat_EmptyThrow() ); } - [Fact] + [TestMethod] public void Concat_ThrowEmpty() { var scheduler = new TestScheduler(); @@ -329,7 +332,7 @@ public void Concat_ThrowEmpty() ); } - [Fact] + [TestMethod] public void Concat_ThrowThrow() { var scheduler = new TestScheduler(); @@ -362,7 +365,7 @@ public void Concat_ThrowThrow() ); } - [Fact] + [TestMethod] public void Concat_ReturnEmpty() { var scheduler = new TestScheduler(); @@ -396,7 +399,7 @@ public void Concat_ReturnEmpty() ); } - [Fact] + [TestMethod] public void Concat_EmptyReturn() { var scheduler = new TestScheduler(); @@ -430,7 +433,7 @@ public void Concat_EmptyReturn() ); } - [Fact] + [TestMethod] public void Concat_ReturnNever() { var scheduler = new TestScheduler(); @@ -462,7 +465,7 @@ public void Concat_ReturnNever() ); } - [Fact] + [TestMethod] public void Concat_NeverReturn() { var scheduler = new TestScheduler(); @@ -492,7 +495,7 @@ public void Concat_NeverReturn() ); } - [Fact] + [TestMethod] public void Concat_ReturnReturn() { var scheduler = new TestScheduler(); @@ -530,7 +533,7 @@ public void Concat_ReturnReturn() ); } - [Fact] + [TestMethod] public void Concat_ThrowReturn() { var scheduler = new TestScheduler(); @@ -564,7 +567,7 @@ public void Concat_ThrowReturn() ); } - [Fact] + [TestMethod] public void Concat_ReturnThrow() { var scheduler = new TestScheduler(); @@ -600,7 +603,7 @@ public void Concat_ReturnThrow() ); } - [Fact] + [TestMethod] public void Concat_SomeDataSomeData() { var scheduler = new TestScheduler(); @@ -642,7 +645,7 @@ public void Concat_SomeDataSomeData() ); } - [Fact] + [TestMethod] public void Concat_EnumerableThrows() { var scheduler = new TestScheduler(); @@ -682,7 +685,7 @@ private IEnumerable> GetObservablesForConcatThrow(IObservable f(int x) => Observable.Defer(() => Observable.Return(x, ThreadPoolScheduler.Instance).Concat(f(x + 1))); @@ -932,7 +935,7 @@ public void Concat_TailRecursive2() #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()); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ContainsTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ContainsTest.cs index 16c3197831..dd0b7ec858 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ContainsTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ContainsTest.cs @@ -8,14 +8,15 @@ 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(() => Observable.Contains(default, 42)); @@ -23,7 +24,7 @@ public void Contains_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Contains(DummyObservable.Instance, 42, null)); } - [Fact] + [TestMethod] public void Contains_Empty() { var scheduler = new TestScheduler(); @@ -47,7 +48,7 @@ public void Contains_Empty() ); } - [Fact] + [TestMethod] public void Contains_ReturnPositive() { var scheduler = new TestScheduler(); @@ -72,7 +73,7 @@ public void Contains_ReturnPositive() ); } - [Fact] + [TestMethod] public void Contains_ReturnNegative() { var scheduler = new TestScheduler(); @@ -97,7 +98,7 @@ public void Contains_ReturnNegative() ); } - [Fact] + [TestMethod] public void Contains_SomePositive() { var scheduler = new TestScheduler(); @@ -124,7 +125,7 @@ public void Contains_SomePositive() ); } - [Fact] + [TestMethod] public void Contains_SomeNegative() { var scheduler = new TestScheduler(); @@ -151,7 +152,7 @@ public void Contains_SomeNegative() ); } - [Fact] + [TestMethod] public void Contains_Throw() { var ex = new Exception(); @@ -176,7 +177,7 @@ public void Contains_Throw() ); } - [Fact] + [TestMethod] public void Contains_Never() { var ex = new Exception(); @@ -199,7 +200,7 @@ public void Contains_Never() ); } - [Fact] + [TestMethod] public void Contains_ComparerThrows() { var ex = new Exception(); @@ -237,7 +238,7 @@ public int GetHashCode(int obj) } } - [Fact] + [TestMethod] public void Contains_ComparerContainsValue() { var ex = new Exception(); @@ -266,7 +267,7 @@ public void Contains_ComparerContainsValue() ); } - [Fact] + [TestMethod] public void Contains_ComparerDoesNotContainValue() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CountTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CountTest.cs index 67ac644bc5..3a43a8a62c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CountTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CountTest.cs @@ -8,13 +8,14 @@ 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(() => Observable.Count(default(IObservable))); @@ -22,7 +23,7 @@ public void Count_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Count(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void Count_Empty() { var scheduler = new TestScheduler(); @@ -46,7 +47,7 @@ public void Count_Empty() ); } - [Fact] + [TestMethod] public void Count_Return() { var scheduler = new TestScheduler(); @@ -71,7 +72,7 @@ public void Count_Return() ); } - [Fact] + [TestMethod] public void Count_Some() { var scheduler = new TestScheduler(); @@ -98,7 +99,7 @@ public void Count_Some() ); } - [Fact] + [TestMethod] public void Count_Throw() { var ex = new Exception(); @@ -123,7 +124,7 @@ public void Count_Throw() ); } - [Fact] + [TestMethod] public void Count_Never() { var scheduler = new TestScheduler(); @@ -145,7 +146,7 @@ public void Count_Never() } #if !NO_PERF && !NO_THREAD - [Fact] + [TestMethod] public void Count_InjectOverflow() { var xs = Observable.Return(42, ThreadPoolScheduler.Instance); @@ -156,7 +157,7 @@ public void Count_InjectOverflow() } #endif - [Fact] + [TestMethod] public void Count_Predicate_Empty_True() { var scheduler = new TestScheduler(); @@ -180,7 +181,7 @@ public void Count_Predicate_Empty_True() ); } - [Fact] + [TestMethod] public void Count_Predicate_Empty_False() { var scheduler = new TestScheduler(); @@ -204,7 +205,7 @@ public void Count_Predicate_Empty_False() ); } - [Fact] + [TestMethod] public void Count_Predicate_Return_True() { var scheduler = new TestScheduler(); @@ -229,7 +230,7 @@ public void Count_Predicate_Return_True() ); } - [Fact] + [TestMethod] public void Count_Predicate_Return_False() { var scheduler = new TestScheduler(); @@ -254,7 +255,7 @@ public void Count_Predicate_Return_False() ); } - [Fact] + [TestMethod] public void Count_Predicate_Some_All() { var scheduler = new TestScheduler(); @@ -281,7 +282,7 @@ public void Count_Predicate_Some_All() ); } - [Fact] + [TestMethod] public void Count_Predicate_Some_None() { var scheduler = new TestScheduler(); @@ -308,7 +309,7 @@ public void Count_Predicate_Some_None() ); } - [Fact] + [TestMethod] public void Count_Predicate_Some_Even() { var scheduler = new TestScheduler(); @@ -335,7 +336,7 @@ public void Count_Predicate_Some_Even() ); } - [Fact] + [TestMethod] public void Count_Predicate_Throw_True() { var ex = new Exception(); @@ -360,7 +361,7 @@ public void Count_Predicate_Throw_True() ); } - [Fact] + [TestMethod] public void Count_Predicate_Throw_False() { var ex = new Exception(); @@ -385,7 +386,7 @@ public void Count_Predicate_Throw_False() ); } - [Fact] + [TestMethod] public void Count_Predicate_Never() { var scheduler = new TestScheduler(); @@ -406,7 +407,7 @@ public void Count_Predicate_Never() ); } - [Fact] + [TestMethod] public void Count_Predicate_PredicateThrows() { var scheduler = new TestScheduler(); @@ -443,7 +444,7 @@ public void Count_Predicate_PredicateThrows() #if !NO_PERF && !NO_THREAD && !CRIPPLED_REFLECTION - [Fact] + [TestMethod] public void Count_Predicate_InjectOverflow() { var xs = Observable.Return(42, ThreadPoolScheduler.Instance); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateAsyncTest.cs index 9c11ee4cda..076e072b31 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateAsyncTest.cs @@ -12,14 +12,17 @@ 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(() => Observable.Create(default(Func, Task>))); @@ -30,7 +33,7 @@ public void CreateAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Create(default(Func, CancellationToken, Task>))); } - [Fact] + [TestMethod] public void CreateAsync_NullCoalescingAction1() { var xs = Observable.Create(o => @@ -46,7 +49,7 @@ public void CreateAsync_NullCoalescingAction1() Assert.True(lst.SequenceEqual(new[] { 42 })); } - [Fact] + [TestMethod] public void CreateAsync_NullCoalescingAction2() { var xs = Observable.Create((o, ct) => @@ -62,7 +65,7 @@ public void CreateAsync_NullCoalescingAction2() Assert.True(lst.SequenceEqual(new[] { 42 })); } - [Fact] + [TestMethod] public void CreateAsync_NullCoalescingDisposable1() { var xs = Observable.Create(o => @@ -78,7 +81,7 @@ public void CreateAsync_NullCoalescingDisposable1() Assert.True(lst.SequenceEqual(new[] { 42 })); } - [Fact] + [TestMethod] public void CreateAsync_NullCoalescingDisposable2() { var xs = Observable.Create((o, ct) => @@ -111,7 +114,7 @@ private Task Producer1(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Never() { RunSynchronously(() => @@ -155,7 +158,7 @@ private Task Producer2(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Completed1() { RunSynchronously(() => @@ -197,7 +200,7 @@ private Task Producer3(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Completed2() { RunSynchronously(() => @@ -239,7 +242,7 @@ private Task Producer4(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Error1() { RunSynchronously(() => @@ -283,7 +286,7 @@ private Task Producer5(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Error2() { RunSynchronously(() => @@ -311,7 +314,7 @@ private Task Producer6(IObserver results, CancellationToken token, Exceptio throw exception; } - [Fact] + [TestMethod] public void CreateAsync_Error3() { RunSynchronously(() => @@ -351,7 +354,7 @@ private Task Producer7(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Cancel1() { RunSynchronously(() => @@ -393,7 +396,7 @@ private Task Producer8(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Cancel2() { RunSynchronously(() => @@ -435,7 +438,7 @@ private Task Producer9(IObserver results, CancellationToken token, ISchedul return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Cancel3() { RunSynchronously(() => @@ -478,7 +481,7 @@ private Task Producer10(IObserver results, CancellationToken token, ISchedu return tcs.Task; } - [Fact] + [TestMethod] public void CreateAsync_Cancel4() { RunSynchronously(() => @@ -529,7 +532,7 @@ protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQu } } - [Fact] + [TestMethod] public void CreateAsync_Task_Simple() { var xs = Observable.Create(observer => @@ -547,7 +550,7 @@ public void CreateAsync_Task_Simple() Assert.True(new[] { 42 }.SequenceEqual(lst)); } - [Fact] + [TestMethod] public void CreateAsync_Task_Token() { var e = new ManualResetEvent(false); @@ -571,15 +574,25 @@ public void CreateAsync_Task_Token() }); var lst = new List(); - 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.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 @@ public void CreateAsync_IDisposable_Simple() Assert.True(new[] { 42 }.SequenceEqual(lst)); } - [Fact] + [TestMethod] public void CreateAsync_IDisposable_Token() { var stopped = new ManualResetEvent(false); @@ -642,7 +655,7 @@ public void CreateAsync_IDisposable_Token() 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 @@ public void CreateAsync_Action_Simple() Assert.True(new[] { 42 }.SequenceEqual(lst)); } - [Fact] + [TestMethod] public void CreateAsync_Action_Token() { var stopped = new ManualResetEvent(false); @@ -706,7 +719,7 @@ public void CreateAsync_Action_Token() } - [Fact] + [TestMethod] public void CreateWithTaskDisposable_NoPrematureTermination() { var obs = Observable.Create(async o => @@ -725,7 +738,7 @@ public void CreateWithTaskDisposable_NoPrematureTermination() var result = obs.Take(1).Wait(); } - [Fact] + [TestMethod] public void CreateWithTaskAction_NoPrematureTermination() { var obs = Observable.Create(async o => diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateTest.cs index 57dc5b470d..aea66f64b2 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/CreateTest.cs @@ -11,14 +11,17 @@ 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(() => Observable.Create(default(Func, Action>))); @@ -37,7 +40,7 @@ public void Create_ArgumentChecking() }).Subscribe(null)); } - [Fact] + [TestMethod] public void Create_NullCoalescingAction() { var xs = Observable.Create(o => @@ -53,7 +56,7 @@ public void Create_NullCoalescingAction() Assert.True(lst.SequenceEqual(new[] { 42 })); } - [Fact] + [TestMethod] public void Create_Next() { var scheduler = new TestScheduler(); @@ -73,7 +76,7 @@ public void Create_Next() ); } - [Fact] + [TestMethod] public void Create_Completed() { var scheduler = new TestScheduler(); @@ -94,7 +97,7 @@ public void Create_Completed() ); } - [Fact] + [TestMethod] public void Create_Error() { var scheduler = new TestScheduler(); @@ -117,14 +120,14 @@ public void Create_Error() ); } - [Fact] + [TestMethod] public void Create_Exception() { ReactiveAssert.Throws(() => Observable.Create(new Func, Action>(o => { throw new InvalidOperationException(); })).Subscribe()); } - [Fact] + [TestMethod] public void Create_Dispose() { var scheduler = new TestScheduler(); @@ -177,7 +180,7 @@ public void Create_Dispose() ); } - [Fact] + [TestMethod] public void Create_ObserverThrows() { ReactiveAssert.Throws(() => @@ -200,7 +203,7 @@ public void Create_ObserverThrows() }).Subscribe(x => { }, ex => { }, () => { throw new InvalidOperationException(); })); } - [Fact] + [TestMethod] public void CreateWithDisposable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Create(default(Func, IDisposable>))); @@ -212,7 +215,7 @@ public void CreateWithDisposable_ArgumentChecking() }).Subscribe(null)); } - [Fact] + [TestMethod] public void CreateWithDisposable_NullCoalescingAction() { var xs = Observable.Create(o => @@ -228,7 +231,7 @@ public void CreateWithDisposable_NullCoalescingAction() Assert.True(lst.SequenceEqual(new[] { 42 })); } - [Fact] + [TestMethod] public void CreateWithDisposable_Next() { var scheduler = new TestScheduler(); @@ -248,7 +251,7 @@ public void CreateWithDisposable_Next() ); } - [Fact] + [TestMethod] public void CreateWithDisposable_Completed() { var scheduler = new TestScheduler(); @@ -269,7 +272,7 @@ public void CreateWithDisposable_Completed() ); } - [Fact] + [TestMethod] public void CreateWithDisposable_Error() { var scheduler = new TestScheduler(); @@ -292,14 +295,14 @@ public void CreateWithDisposable_Error() ); } - [Fact] + [TestMethod] public void CreateWithDisposable_Exception() { ReactiveAssert.Throws(() => Observable.Create(new Func, IDisposable>(o => { throw new InvalidOperationException(); })).Subscribe()); } - [Fact] + [TestMethod] public void CreateWithDisposable_Dispose() { var scheduler = new TestScheduler(); @@ -352,7 +355,7 @@ public void CreateWithDisposable_Dispose() ); } - [Fact] + [TestMethod] public void CreateWithDisposable_ObserverThrows() { ReactiveAssert.Throws(() => @@ -375,7 +378,7 @@ public void CreateWithDisposable_ObserverThrows() }).Subscribe(x => { }, ex => { }, () => { throw new InvalidOperationException(); })); } - [Fact] + [TestMethod] public void Iterate_ArgumentChecking() { ReactiveAssert.Throws(() => ObservableEx.Create(default)); @@ -397,7 +400,7 @@ private IEnumerable> ToIterate_Complete(IObservable xs, observer.OnNext(4); } - [Fact] + [TestMethod] public void Iterate_Complete() { var scheduler = new TestScheduler(); @@ -461,7 +464,7 @@ private IEnumerable> ToIterate_Complete_Implicit(IObservable observer.OnNext(4); } - [Fact] + [TestMethod] public void Iterate_Complete_Implicit() { var scheduler = new TestScheduler(); @@ -533,7 +536,7 @@ private IEnumerable> ToIterate_Throw(IObservable xs, IO observer.OnCompleted(); } - [Fact] + [TestMethod] public void Iterate_Iterator_Throw() { var scheduler = new TestScheduler(); @@ -602,7 +605,7 @@ private IEnumerable> ToIterate_Error(IObservable xs, IO observer.OnCompleted(); } - [Fact] + [TestMethod] public void Iterate_Iterator_Error() { var scheduler = new TestScheduler(); @@ -666,7 +669,7 @@ private IEnumerable> ToIterate_Complete_Dispose(IObservable< observer.OnNext(4); } - [Fact] + [TestMethod] public void Iterate_Complete_Dispose() { var scheduler = new TestScheduler(); @@ -719,7 +722,7 @@ public void Iterate_Complete_Dispose() ); } - [Fact] + [TestMethod] public void IteratorScenario() { var xs = ObservableEx.Create(o => _IteratorScenario(100, 1000, o)); @@ -740,7 +743,7 @@ private static IEnumerable> _IteratorScenario(int x, int y, results.OnNext(ys.Value); } - [Fact] + [TestMethod] public void Iterate_Void_ArgumentChecking() { ReactiveAssert.Throws(() => ObservableEx.Create(default)); @@ -756,7 +759,7 @@ private IEnumerable> ToIterate_Void_Complete(IObservable new object()); } - [Fact] + [TestMethod] public void Iterate_Void_Complete() { var scheduler = new TestScheduler(); @@ -812,7 +815,7 @@ private IEnumerable> ToIterate_Void_Complete_Implicit(IObser yield return zs.Select(x => new object()); } - [Fact] + [TestMethod] public void Iterate_Void_Complete_Implicit() { var scheduler = new TestScheduler(); @@ -873,7 +876,7 @@ private IEnumerable> ToIterate_Void_Throw(IObservable x yield return zs.Select(x => new object()); } - [Fact] + [TestMethod] public void Iterate_Void_Iterator_Throw() { var scheduler = new TestScheduler(); @@ -930,7 +933,7 @@ private IEnumerable> ToIterate_Void_Complete_Dispose(IObserv yield return zs.Select(x => new object()); } - [Fact] + [TestMethod] public void Iterate_Void_Complete_Dispose() { var scheduler = new TestScheduler(); @@ -980,7 +983,7 @@ public void Iterate_Void_Complete_Dispose() ); } - [Fact] + [TestMethod] public void Iterate_Void_Func_Throw() { var scheduler = new TestScheduler(); @@ -1003,7 +1006,7 @@ private static IEnumerable> _IteratorScenario_Void(int x, in yield return ys; } - [Fact] + [TestMethod] public void IteratorScenario_Void() { var xs = ObservableEx.Create(() => _IteratorScenario_Void(100, 1000)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DefaultIfEmptyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DefaultIfEmptyTest.cs index a9b024a941..d62f1bb780 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DefaultIfEmptyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DefaultIfEmptyTest.cs @@ -6,21 +6,22 @@ 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(() => Observable.DefaultIfEmpty(default(IObservable))); ReactiveAssert.Throws(() => Observable.DefaultIfEmpty(default, 42)); } - [Fact] + [TestMethod] public void DefaultIfEmpty_NonEmpty1() { var scheduler = new TestScheduler(); @@ -46,7 +47,7 @@ public void DefaultIfEmpty_NonEmpty1() ); } - [Fact] + [TestMethod] public void DefaultIfEmpty_NonEmpty2() { var scheduler = new TestScheduler(); @@ -72,7 +73,7 @@ public void DefaultIfEmpty_NonEmpty2() ); } - [Fact] + [TestMethod] public void DefaultIfEmpty_Empty1() { var scheduler = new TestScheduler(); @@ -95,7 +96,7 @@ public void DefaultIfEmpty_Empty1() ); } - [Fact] + [TestMethod] public void DefaultIfEmpty_Empty2() { var scheduler = new TestScheduler(); @@ -118,7 +119,7 @@ public void DefaultIfEmpty_Empty2() ); } - [Fact] + [TestMethod] public void DefaultIfEmpty_Throw1() { var ex = new Exception(); @@ -142,7 +143,7 @@ public void DefaultIfEmpty_Throw1() ); } - [Fact] + [TestMethod] public void DefaultIfEmpty_Throw2() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferAsyncTest.cs index 58ae136d79..bc6c2fc0db 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferAsyncTest.cs @@ -8,21 +8,24 @@ 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(() => Observable.Defer(default(Func>>))); ReactiveAssert.Throws(() => Observable.DeferAsync(default(Func>>))); } - [Fact] + [TestMethod] public void DeferAsync_Simple() { var xs = Observable.Defer(() => Task.Factory.StartNew(() => Observable.Return(42))); @@ -32,7 +35,7 @@ public void DeferAsync_Simple() 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 @@ public void DeferAsync_WithCancel_Simple() Assert.True(new[] { 42 }.SequenceEqual(res)); } - [Fact] + [TestMethod] public void DeferAsync_WithCancel_Cancel() { var N = 10;// 0000; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferTest.cs index 7c8ffa51f2..fc208fb1e5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DeferTest.cs @@ -6,14 +6,17 @@ 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(() => Observable.Defer(default(Func>))); @@ -21,7 +24,7 @@ public void Defer_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Defer(() => default(IObservable)).Subscribe()); } - [Fact] + [TestMethod] public void Defer_Complete() { var scheduler = new TestScheduler(); @@ -52,7 +55,7 @@ public void Defer_Complete() ); } - [Fact] + [TestMethod] public void Defer_Error() { var scheduler = new TestScheduler(); @@ -84,7 +87,7 @@ public void Defer_Error() ); } - [Fact] + [TestMethod] public void Defer_Dispose() { var scheduler = new TestScheduler(); @@ -116,7 +119,7 @@ public void Defer_Dispose() ); } - [Fact] + [TestMethod] public void Defer_Throw() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelaySubscriptionTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelaySubscriptionTest.cs index 376c50d9cb..ff4712667e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelaySubscriptionTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelaySubscriptionTest.cs @@ -9,14 +9,17 @@ 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(() => Observable.DelaySubscription(default(IObservable), DateTimeOffset.Now)); @@ -31,7 +34,7 @@ public void DelaySubscription_ArgumentChecking() ReactiveAssert.Throws(() => Observable.DelaySubscription(DummyObservable.Instance, TimeSpan.FromSeconds(-1), Scheduler.Immediate)); } - [Fact] + [TestMethod] public void DelaySubscription_TimeSpan_Default() { var lst = new List(); @@ -39,7 +42,7 @@ public void DelaySubscription_TimeSpan_Default() Assert.True(Enumerable.Range(0, 10).SequenceEqual(lst)); } - [Fact] + [TestMethod] public void DelaySubscription_TimeSpan_Simple() { var scheduler = new TestScheduler(); @@ -65,7 +68,7 @@ public void DelaySubscription_TimeSpan_Simple() ); } - [Fact] + [TestMethod] public void DelaySubscription_TimeSpan_Error() { var ex = new Exception(); @@ -93,7 +96,7 @@ public void DelaySubscription_TimeSpan_Error() ); } - [Fact] + [TestMethod] public void DelaySubscription_DateTimeOffset_Default() { var lst = new List(); @@ -101,7 +104,7 @@ public void DelaySubscription_DateTimeOffset_Default() Assert.True(Enumerable.Range(0, 10).SequenceEqual(lst)); } - [Fact] + [TestMethod] public void DelaySubscription_DateTimeOffset_Simple() { var scheduler = new TestScheduler(); @@ -127,7 +130,7 @@ public void DelaySubscription_DateTimeOffset_Simple() ); } - [Fact] + [TestMethod] public void DelaySubscription_DateTimeOffset_Error() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelayTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelayTest.cs index 0bc157cbfd..571c8461d7 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelayTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DelayTest.cs @@ -14,14 +14,17 @@ 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 @@ public void Delay_ArgumentChecking() ReactiveAssert.Throws(() => 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 @@ private void Delay_TimeSpan_Simple1_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_DateTimeOffset_Simple1_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_TimeSpan_Simple2_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_DateTimeOffset_Simple2_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_TimeSpan_Simple3_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_DateTimeOffset_Simple3_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_TimeSpan_Error1_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_DateTimeOffset_Error1_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_TimeSpan_Error2_Impl(bool useStopwatch) ); } - [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 @@ private void Delay_DateTimeOffset_Error2_Impl(bool useStopwatch) } #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 @@ private void Delay_TimeSpan_Real_Simple1_Impl(IScheduler scheduler) } #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 @@ private void Delay_TimeSpan_Real_Error1_Impl(IScheduler scheduler) } #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 @@ private void Delay_TimeSpan_Real_Error2_Impl(IScheduler scheduler) } #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 @@ private void Delay_TimeSpan_Real_Error3_Impl(IScheduler scheduler) Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Delay_TimeSpan_Positive() { var scheduler = new TestScheduler(); @@ -627,7 +630,7 @@ where n.Time > Subscribed res.Messages.AssertEqual(expected); } - [Fact] + [TestMethod] public void Delay_Empty() { var scheduler = new TestScheduler(); @@ -650,7 +653,7 @@ public void Delay_Empty() ); } - [Fact] + [TestMethod] public void Delay_Error() { var scheduler = new TestScheduler(); @@ -675,7 +678,7 @@ public void Delay_Error() ); } - [Fact] + [TestMethod] public void Delay_Never() { var scheduler = new TestScheduler(); @@ -696,19 +699,19 @@ public void Delay_Never() ); } - [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(); @@ -738,7 +741,7 @@ public void Delay_CrossingMessages() Assert.True(Enumerable.Range(0, 10).SequenceEqual(lst)); } - [Fact] + [TestMethod] public void Delay_Duration_ArgumentChecking() { var someObservable = DummyObservable.Instance; @@ -750,7 +753,7 @@ public void Delay_Duration_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Delay(someObservable, someObservable, default)); } - [Fact] + [TestMethod] public void Delay_Duration_Simple1() { var scheduler = new TestScheduler(); @@ -783,7 +786,7 @@ public void Delay_Duration_Simple1() ); } - [Fact] + [TestMethod] public void Delay_Duration_Simple2() { var scheduler = new TestScheduler(); @@ -828,7 +831,7 @@ public void Delay_Duration_Simple2() ); } - [Fact] + [TestMethod] public void Delay_Duration_Simple3() { var scheduler = new TestScheduler(); @@ -873,7 +876,7 @@ public void Delay_Duration_Simple3() ); } - [Fact] + [TestMethod] public void Delay_Duration_Simple4_InnerEmpty() { var scheduler = new TestScheduler(); @@ -918,7 +921,7 @@ public void Delay_Duration_Simple4_InnerEmpty() ); } - [Fact] + [TestMethod] public void Delay_Duration_Dispose1() { var scheduler = new TestScheduler(); @@ -960,7 +963,7 @@ public void Delay_Duration_Dispose1() ); } - [Fact] + [TestMethod] public void Delay_Duration_Dispose2() { var scheduler = new TestScheduler(); @@ -994,7 +997,7 @@ public void Delay_Duration_Dispose2() ); } - [Fact] + [TestMethod] public void Delay_Duration_OuterError1() { var scheduler = new TestScheduler(); @@ -1036,7 +1039,7 @@ public void Delay_Duration_OuterError1() ); } - [Fact] + [TestMethod] public void Delay_Duration_OuterError2() { var scheduler = new TestScheduler(); @@ -1083,7 +1086,7 @@ public void Delay_Duration_OuterError2() ); } - [Fact] + [TestMethod] public void Delay_Duration_InnerError1() { var scheduler = new TestScheduler(); @@ -1131,7 +1134,7 @@ public void Delay_Duration_InnerError1() ); } - [Fact] + [TestMethod] public void Delay_Duration_InnerError2() { var scheduler = new TestScheduler(); @@ -1173,7 +1176,7 @@ public void Delay_Duration_InnerError2() ); } - [Fact] + [TestMethod] public void Delay_Duration_SelectorThrows1() { var scheduler = new TestScheduler(); @@ -1221,7 +1224,7 @@ public void Delay_Duration_SelectorThrows1() ); } - [Fact] + [TestMethod] public void Delay_Duration_Simple() { var scheduler = new TestScheduler(); @@ -1255,7 +1258,7 @@ public void Delay_Duration_Simple() ); } - [Fact] + [TestMethod] public void Delay_Duration_DeferOnCompleted() { var scheduler = new TestScheduler(); @@ -1289,7 +1292,7 @@ public void Delay_Duration_DeferOnCompleted() ); } - [Fact] + [TestMethod] public void Delay_Duration_InnerError() { var scheduler = new TestScheduler(); @@ -1327,7 +1330,7 @@ public void Delay_Duration_InnerError() ); } - [Fact] + [TestMethod] public void Delay_Duration_OuterError() { var scheduler = new TestScheduler(); @@ -1362,7 +1365,7 @@ public void Delay_Duration_OuterError() ); } - [Fact] + [TestMethod] public void Delay_Duration_SelectorThrows2() { var scheduler = new TestScheduler(); @@ -1405,7 +1408,7 @@ public void Delay_Duration_SelectorThrows2() ); } - [Fact] + [TestMethod] public void Delay_Duration_Selector_Immediately() { var list = new List(); @@ -1417,7 +1420,7 @@ public void Delay_Duration_Selector_Immediately() Assert.Equal(new List() { 1, 2, 3, 4, 5 }, list); } - [Fact] + [TestMethod] public void Delay_Duration_InnerDone() { var scheduler = new TestScheduler(); @@ -1452,7 +1455,7 @@ public void Delay_Duration_InnerDone() ); } - [Fact] + [TestMethod] public void Delay_Duration_InnerSubscriptionTimes() { var scheduler = new TestScheduler(); @@ -1500,7 +1503,7 @@ public void Delay_Duration_InnerSubscriptionTimes() ys[2].Subscriptions.AssertEqual(Subscribe(450, 450 + 30)); } - [Fact] + [TestMethod] public void Delay_DurationAndSubscription_Simple1() { var scheduler = new TestScheduler(); @@ -1540,7 +1543,7 @@ public void Delay_DurationAndSubscription_Simple1() ); } - [Fact] + [TestMethod] public void Delay_DurationAndSubscription_Simple2() { var scheduler = new TestScheduler(); @@ -1580,7 +1583,7 @@ public void Delay_DurationAndSubscription_Simple2() ); } - [Fact] + [TestMethod] public void Delay_DurationAndSubscription_Dispose1() { var scheduler = new TestScheduler(); @@ -1617,7 +1620,7 @@ public void Delay_DurationAndSubscription_Dispose1() ); } - [Fact] + [TestMethod] public void Delay_DurationAndSubscription_Dispose2() { var scheduler = new TestScheduler(); @@ -1652,7 +1655,7 @@ public void Delay_DurationAndSubscription_Dispose2() ); } - [Fact] + [TestMethod] public void Delay_DurationAndSubscription_Error() { var scheduler = new TestScheduler(); @@ -1689,7 +1692,7 @@ public void Delay_DurationAndSubscription_Error() ); } - [Fact] + [TestMethod] public void Delay_ErrorHandling1() { // @@ -1756,7 +1759,7 @@ public IDisposable Schedule(TState state, DateTimeOffset dueTime, Func(observer => @@ -1808,7 +1811,7 @@ public override IDisposable Schedule(TState state, TimeSpan dueTime, Fun } } - [Fact] + [TestMethod] public void Delay_LongRunning_CancelLate() { var xs = Observable.Return(42); @@ -1825,7 +1828,7 @@ public void Delay_LongRunning_CancelLate() e.WaitOne(); } - [Fact] + [TestMethod] public void Delay_Selector_Immediate() { var result = 0; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DematerializeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DematerializeTest.cs index 34b88e0f1c..62c1f1b85f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DematerializeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DematerializeTest.cs @@ -6,20 +6,21 @@ 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(() => Observable.Dematerialize(null)); } - [Fact] + [TestMethod] public void Dematerialize_Range1() { var scheduler = new TestScheduler(); @@ -45,7 +46,7 @@ public void Dematerialize_Range1() ); } - [Fact] + [TestMethod] public void Dematerialize_Range2() { var scheduler = new TestScheduler(); @@ -71,7 +72,7 @@ public void Dematerialize_Range2() ); } - [Fact] + [TestMethod] public void Dematerialize_Error1() { var scheduler = new TestScheduler(); @@ -99,7 +100,7 @@ public void Dematerialize_Error1() ); } - [Fact] + [TestMethod] public void Dematerialize_Error2() { var scheduler = new TestScheduler(); @@ -127,7 +128,7 @@ public void Dematerialize_Error2() ); } - [Fact] + [TestMethod] public void Materialize_Dematerialize_Never() { var scheduler = new TestScheduler(); @@ -142,7 +143,7 @@ public void Materialize_Dematerialize_Never() ); } - [Fact] + [TestMethod] public void Materialize_Dematerialize_Empty() { var scheduler = new TestScheduler(); @@ -165,7 +166,7 @@ public void Materialize_Dematerialize_Empty() ); } - [Fact] + [TestMethod] public void Materialize_Dematerialize_Return() { var scheduler = new TestScheduler(); @@ -190,7 +191,7 @@ public void Materialize_Dematerialize_Return() ); } - [Fact] + [TestMethod] public void Materialize_Dematerialize_Throw() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctTest.cs index 616ed18cad..b809ddd41e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctTest.cs @@ -8,14 +8,15 @@ 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(() => Observable.Distinct(default(IObservable))); @@ -28,7 +29,7 @@ public void Distinct_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Distinct(DummyObservable.Instance, x => x, default(EqualityComparer))); } - [Fact] + [TestMethod] public void Distinct_DefaultComparer_AllDistinct() { var scheduler = new TestScheduler(); @@ -60,7 +61,7 @@ public void Distinct_DefaultComparer_AllDistinct() ); } - [Fact] + [TestMethod] public void Distinct_DefaultComparer_SomeDuplicates() { var scheduler = new TestScheduler(); @@ -90,7 +91,7 @@ public void Distinct_DefaultComparer_SomeDuplicates() ); } - [Fact] + [TestMethod] public void Distinct_CustomComparer_AllDistinct() { var scheduler = new TestScheduler(); @@ -122,7 +123,7 @@ public void Distinct_CustomComparer_AllDistinct() ); } - [Fact] + [TestMethod] public void Distinct_CustomComparer_SomeDuplicates() { var scheduler = new TestScheduler(); @@ -172,7 +173,7 @@ public int GetHashCode(int obj) } } - [Fact] + [TestMethod] public void Distinct_KeySelector_DefaultComparer_AllDistinct() { var scheduler = new TestScheduler(); @@ -204,7 +205,7 @@ public void Distinct_KeySelector_DefaultComparer_AllDistinct() ); } - [Fact] + [TestMethod] public void Distinct_KeySelector_DefaultComparer_SomeDuplicates() { var scheduler = new TestScheduler(); @@ -234,7 +235,7 @@ public void Distinct_KeySelector_DefaultComparer_SomeDuplicates() ); } - [Fact] + [TestMethod] public void Distinct_KeySelector_CustomComparer_AllDistinct() { var scheduler = new TestScheduler(); @@ -266,7 +267,7 @@ public void Distinct_KeySelector_CustomComparer_AllDistinct() ); } - [Fact] + [TestMethod] public void Distinct_KeySelector_CustomComparer_SomeDuplicates() { var scheduler = new TestScheduler(); @@ -296,7 +297,7 @@ public void Distinct_KeySelector_CustomComparer_SomeDuplicates() ); } - [Fact] + [TestMethod] public void Distinct_KeySelector_Throws() { var scheduler = new TestScheduler(); @@ -327,7 +328,7 @@ public void Distinct_KeySelector_Throws() ); } - [Fact] + [TestMethod] public void Distinct_CustomComparer_Throws() { var scheduler = new TestScheduler(); @@ -386,7 +387,7 @@ public int GetHashCode(int obj) } } - [Fact] + [TestMethod] public void Distinct_Throw() { var scheduler = new TestScheduler(); @@ -416,7 +417,7 @@ public void Distinct_Throw() ); } - [Fact] + [TestMethod] public void Distinct_Null() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctUntilChangedTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctUntilChangedTest.cs index 2c3a38b57e..3e4f0416af 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctUntilChangedTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DistinctUntilChangedTest.cs @@ -6,14 +6,15 @@ 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(); @@ -28,7 +29,7 @@ public void DistinctUntilChanged_ArgumentChecking() ReactiveAssert.Throws(() => Observable.DistinctUntilChanged(someObservable, null, EqualityComparer.Default)); } - [Fact] + [TestMethod] public void DistinctUntilChanged_Never() { var scheduler = new TestScheduler(); @@ -43,7 +44,7 @@ public void DistinctUntilChanged_Never() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_Empty() { var scheduler = new TestScheduler(); @@ -66,7 +67,7 @@ public void DistinctUntilChanged_Empty() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_Return() { var scheduler = new TestScheduler(); @@ -91,7 +92,7 @@ public void DistinctUntilChanged_Return() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_Throw() { var scheduler = new TestScheduler(); @@ -115,7 +116,7 @@ public void DistinctUntilChanged_Throw() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_AllChanges() { var scheduler = new TestScheduler(); @@ -146,7 +147,7 @@ public void DistinctUntilChanged_AllChanges() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_AllSame() { var scheduler = new TestScheduler(); @@ -174,7 +175,7 @@ public void DistinctUntilChanged_AllSame() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_SomeChanges() { var scheduler = new TestScheduler(); @@ -209,7 +210,7 @@ public void DistinctUntilChanged_SomeChanges() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_Comparer_AllEqual() { var scheduler = new TestScheduler(); @@ -237,7 +238,7 @@ public void DistinctUntilChanged_Comparer_AllEqual() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_Comparer_AllDifferent() { var scheduler = new TestScheduler(); @@ -268,7 +269,7 @@ public void DistinctUntilChanged_Comparer_AllDifferent() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_KeySelector_Div2() { var scheduler = new TestScheduler(); @@ -317,7 +318,7 @@ public int GetHashCode(T obj) } } - [Fact] + [TestMethod] public void DistinctUntilChanged_KeySelectorThrows() { var ex = new Exception(); @@ -339,7 +340,7 @@ public void DistinctUntilChanged_KeySelectorThrows() ); } - [Fact] + [TestMethod] public void DistinctUntilChanged_ComparerThrows() { var ex = new Exception(); @@ -383,7 +384,7 @@ public int GetHashCode(T obj) } } - [Fact] + [TestMethod] public void DistinctUntilChanged_KeySelector_Comparer() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoTest.cs index 2e4add4599..2d0db33255 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoTest.cs @@ -6,14 +6,17 @@ 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(); @@ -34,7 +37,7 @@ public void Do_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Do(someObservable, default(IObserver))); } - [Fact] + [TestMethod] public void Do_ShouldSeeAllValues() { var scheduler = new TestScheduler(); @@ -70,7 +73,7 @@ public void Do_ShouldSeeAllValues() ); } - [Fact] + [TestMethod] public void Do_PlainAction() { var scheduler = new TestScheduler(); @@ -104,7 +107,7 @@ public void Do_PlainAction() ); } - [Fact] + [TestMethod] public void Do_NextCompleted() { var scheduler = new TestScheduler(); @@ -142,7 +145,7 @@ public void Do_NextCompleted() ); } - [Fact] + [TestMethod] public void Do_NextCompleted_Never() { var scheduler = new TestScheduler(); @@ -166,7 +169,7 @@ public void Do_NextCompleted_Never() ); } - [Fact] + [TestMethod] public void Do_NextError() { var scheduler = new TestScheduler(); @@ -206,7 +209,7 @@ public void Do_NextError() ); } - [Fact] + [TestMethod] public void Do_NextErrorNot() { var scheduler = new TestScheduler(); @@ -244,7 +247,7 @@ public void Do_NextErrorNot() ); } - [Fact] + [TestMethod] public void Do_NextErrorCompleted() { var scheduler = new TestScheduler(); @@ -284,7 +287,7 @@ public void Do_NextErrorCompleted() ); } - [Fact] + [TestMethod] public void Do_NextErrorCompletedError() { var scheduler = new TestScheduler(); @@ -326,7 +329,7 @@ public void Do_NextErrorCompletedError() ); } - [Fact] + [TestMethod] public void Do_NextErrorCompletedNever() { var scheduler = new TestScheduler(); @@ -352,7 +355,7 @@ public void Do_NextErrorCompletedNever() ); } - [Fact] + [TestMethod] public void Do_Observer_SomeDataWithError() { var scheduler = new TestScheduler(); @@ -394,7 +397,7 @@ public void Do_Observer_SomeDataWithError() ); } - [Fact] + [TestMethod] public void Do_Observer_SomeDataWithoutError() { var scheduler = new TestScheduler(); @@ -434,7 +437,7 @@ public void Do_Observer_SomeDataWithoutError() ); } - [Fact] + [TestMethod] public void Do1422_Next_NextThrows() { var scheduler = new TestScheduler(); @@ -460,7 +463,7 @@ public void Do1422_Next_NextThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextCompleted_NextThrows() { var scheduler = new TestScheduler(); @@ -486,7 +489,7 @@ public void Do1422_NextCompleted_NextThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextCompleted_CompletedThrows() { var scheduler = new TestScheduler(); @@ -513,7 +516,7 @@ public void Do1422_NextCompleted_CompletedThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextError_NextThrows() { var scheduler = new TestScheduler(); @@ -539,7 +542,7 @@ public void Do1422_NextError_NextThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextError_ErrorThrows() { var scheduler = new TestScheduler(); @@ -565,7 +568,7 @@ public void Do1422_NextError_ErrorThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextErrorCompleted_NextThrows() { var scheduler = new TestScheduler(); @@ -591,7 +594,7 @@ public void Do1422_NextErrorCompleted_NextThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextErrorCompleted_ErrorThrows() { var scheduler = new TestScheduler(); @@ -617,7 +620,7 @@ public void Do1422_NextErrorCompleted_ErrorThrows() ); } - [Fact] + [TestMethod] public void Do1422_NextErrorCompleted_CompletedThrows() { var scheduler = new TestScheduler(); @@ -644,7 +647,7 @@ public void Do1422_NextErrorCompleted_CompletedThrows() ); } - [Fact] + [TestMethod] public void Do1422_Observer_NextThrows() { var scheduler = new TestScheduler(); @@ -670,7 +673,7 @@ public void Do1422_Observer_NextThrows() ); } - [Fact] + [TestMethod] public void Do1422_Observer_ErrorThrows() { var scheduler = new TestScheduler(); @@ -696,7 +699,7 @@ public void Do1422_Observer_ErrorThrows() ); } - [Fact] + [TestMethod] public void Do1422_Observer_CompletedThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoWhileTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoWhileTest.cs index a1ec7dbb95..5e5d7d45b8 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoWhileTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/DoWhileTest.cs @@ -6,21 +6,22 @@ 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(() => Observable.DoWhile(DummyObservable.Instance, null)); ReactiveAssert.Throws(() => Observable.DoWhile(default(IObservable), DummyFunc.Instance)); } - [Fact] + [TestMethod] public void DoWhile_AlwaysFalse() { var scheduler = new TestScheduler(); @@ -48,7 +49,7 @@ public void DoWhile_AlwaysFalse() ); } - [Fact] + [TestMethod] public void DoWhile_AlwaysTrue() { var scheduler = new TestScheduler(); @@ -86,7 +87,7 @@ public void DoWhile_AlwaysTrue() ); } - [Fact] + [TestMethod] public void DoWhile_AlwaysTrue_Throw() { var scheduler = new TestScheduler(); @@ -108,7 +109,7 @@ public void DoWhile_AlwaysTrue_Throw() ); } - [Fact] + [TestMethod] public void DoWhile_AlwaysTrue_Infinite() { var scheduler = new TestScheduler(); @@ -128,7 +129,7 @@ public void DoWhile_AlwaysTrue_Infinite() ); } - [Fact] + [TestMethod] public void DoWhile_SometimesTrue() { var scheduler = new TestScheduler(); @@ -168,7 +169,7 @@ public void DoWhile_SometimesTrue() ); } - [Fact] + [TestMethod] public void DoWhile_SometimesThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtOrDefaultTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtOrDefaultTest.cs index 69829bab6c..48c3335914 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtOrDefaultTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtOrDefaultTest.cs @@ -7,21 +7,22 @@ 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(() => Observable.ElementAtOrDefault(default(IObservable), 2)); ReactiveAssert.Throws(() => Observable.ElementAtOrDefault(DummyObservable.Instance, -1)); } - [Fact] + [TestMethod] public void ElementAtOrDefault_First() { var scheduler = new TestScheduler(); @@ -47,7 +48,7 @@ public void ElementAtOrDefault_First() ); } - [Fact] + [TestMethod] public void ElementAtOrDefault_Other() { var scheduler = new TestScheduler(); @@ -73,7 +74,7 @@ public void ElementAtOrDefault_Other() ); } - [Fact] + [TestMethod] public void ElementAtOrDefault_OutOfRange() { var scheduler = new TestScheduler(); @@ -99,7 +100,7 @@ public void ElementAtOrDefault_OutOfRange() ); } - [Fact] + [TestMethod] public void ElementAtOrDefault_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtTest.cs index 6266472232..ba0393bb4d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ElementAtTest.cs @@ -7,21 +7,22 @@ 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(() => Observable.ElementAt(default(IObservable), 2)); ReactiveAssert.Throws(() => Observable.ElementAt(DummyObservable.Instance, -1)); } - [Fact] + [TestMethod] public void ElementAt_First() { var scheduler = new TestScheduler(); @@ -47,7 +48,7 @@ public void ElementAt_First() ); } - [Fact] + [TestMethod] public void ElementAt_Other() { var scheduler = new TestScheduler(); @@ -73,7 +74,7 @@ public void ElementAt_Other() ); } - [Fact] + [TestMethod] public void ElementAt_OutOfRange() { var scheduler = new TestScheduler(); @@ -94,7 +95,7 @@ public void ElementAt_OutOfRange() ); } - [Fact] + [TestMethod] public void ElementAt_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/EmptyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/EmptyTest.cs index 5473f352c9..c7e20b07ea 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/EmptyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/EmptyTest.cs @@ -8,14 +8,17 @@ 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(() => Observable.Empty(null)); @@ -23,7 +26,7 @@ public void Empty_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Empty(DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Empty_Basic() { var scheduler = new TestScheduler(); @@ -37,7 +40,7 @@ public void Empty_Basic() ); } - [Fact] + [TestMethod] public void Empty_Disposed() { var scheduler = new TestScheduler(); @@ -51,7 +54,7 @@ public void Empty_Disposed() ); } - [Fact] + [TestMethod] public void Empty_ObserverThrows() { var scheduler1 = new TestScheduler(); @@ -63,13 +66,13 @@ public void Empty_ObserverThrows() ReactiveAssert.Throws(() => scheduler1.Start()); } - [Fact] + [TestMethod] public void Empty_DefaultScheduler() { Observable.Empty().AssertEqual(Observable.Empty(DefaultScheduler.Instance)); } - [Fact] + [TestMethod] public void Empty_Basic_Witness1() { var scheduler = new TestScheduler(); @@ -83,7 +86,7 @@ public void Empty_Basic_Witness1() ); } - [Fact] + [TestMethod] public void Empty_Basic_Witness2() { var e = new ManualResetEvent(false); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ExpandTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ExpandTest.cs index c51bc33923..7569a00923 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ExpandTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ExpandTest.cs @@ -7,14 +7,17 @@ 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(() => ObservableEx.Expand(null, DummyFunc>.Instance, DummyScheduler.Instance)); @@ -24,7 +27,7 @@ public void Expand_ArgumentChecking() ReactiveAssert.Throws(() => ObservableEx.Expand(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void Expand_Default() { var b = Observable.Return(1).Expand(x => x < 10 ? Observable.Return(x + 1) : Observable.Empty()) @@ -33,7 +36,7 @@ public void Expand_Default() Assert.True(b); } - [Fact] + [TestMethod] public void Expand_Empty() { var scheduler = new TestScheduler(); @@ -59,7 +62,7 @@ public void Expand_Empty() ); } - [Fact] + [TestMethod] public void Expand_Error() { var scheduler = new TestScheduler(); @@ -87,7 +90,7 @@ public void Expand_Error() ); } - [Fact] + [TestMethod] public void Expand_Never() { var scheduler = new TestScheduler(); @@ -111,7 +114,7 @@ public void Expand_Never() ); } - [Fact] + [TestMethod] public void Expand_Basic() { var scheduler = new TestScheduler(); @@ -152,7 +155,7 @@ public void Expand_Basic() ); } - [Fact] + [TestMethod] public void Expand_Throw() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FinallyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FinallyTest.cs index 69901c9958..02a37d36fe 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FinallyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FinallyTest.cs @@ -6,14 +6,17 @@ 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(); @@ -22,7 +25,7 @@ public void Finally_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Finally(someObservable, null)); } - [Fact] + [TestMethod] public void Finally_Never() { var scheduler = new TestScheduler(); @@ -38,7 +41,7 @@ public void Finally_Never() Assert.True(invoked); // due to unsubscribe; see 1356 } - [Fact] + [TestMethod] public void Finally_OnlyCalledOnce_Never() { var invokeCount = 0; @@ -50,7 +53,7 @@ public void Finally_OnlyCalledOnce_Never() Assert.Equal(1, invokeCount); } - [Fact] + [TestMethod] public void Finally_OnlyCalledOnce_Empty() { var invokeCount = 0; @@ -62,7 +65,7 @@ public void Finally_OnlyCalledOnce_Empty() Assert.Equal(1, invokeCount); } - [Fact] + [TestMethod] public void Finally_Empty() { var scheduler = new TestScheduler(); @@ -88,7 +91,7 @@ public void Finally_Empty() ); } - [Fact] + [TestMethod] public void Finally_Return() { var scheduler = new TestScheduler(); @@ -116,7 +119,7 @@ public void Finally_Return() ); } - [Fact] + [TestMethod] public void Finally_Throw() { var scheduler = new TestScheduler(); @@ -143,7 +146,7 @@ public void Finally_Throw() ); } - [Fact] + [TestMethod] public void Finally_DisposeOrder_Empty() { var order = ""; @@ -157,7 +160,7 @@ public void Finally_DisposeOrder_Empty() Assert.Equal("123", order); } - [Fact] + [TestMethod] public void Finally_DisposeOrder_Return() { var order = ""; @@ -171,7 +174,7 @@ public void Finally_DisposeOrder_Return() Assert.Equal("123", order); } - [Fact] + [TestMethod] public void Finally_DisposeOrder_Never() { var order = ""; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstAsyncTest.cs index fbbc87a985..74daea456e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstAsyncTest.cs @@ -6,13 +6,14 @@ 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(() => Observable.FirstAsync(default(IObservable))); @@ -20,7 +21,7 @@ public void FirstAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FirstAsync(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void FirstAsync_Empty() { var scheduler = new TestScheduler(); @@ -43,7 +44,7 @@ public void FirstAsync_Empty() ); } - [Fact] + [TestMethod] public void FirstAsync_One() { var scheduler = new TestScheduler(); @@ -68,7 +69,7 @@ public void FirstAsync_One() ); } - [Fact] + [TestMethod] public void FirstAsync_Many() { var scheduler = new TestScheduler(); @@ -94,7 +95,7 @@ public void FirstAsync_Many() ); } - [Fact] + [TestMethod] public void FirstAsync_Error() { var scheduler = new TestScheduler(); @@ -119,7 +120,7 @@ public void FirstAsync_Error() ); } - [Fact] + [TestMethod] public void FirstAsync_Predicate() { var scheduler = new TestScheduler(); @@ -147,7 +148,7 @@ public void FirstAsync_Predicate() ); } - [Fact] + [TestMethod] public void FirstAsync_Predicate_None() { var scheduler = new TestScheduler(); @@ -174,7 +175,7 @@ public void FirstAsync_Predicate_None() ); } - [Fact] + [TestMethod] public void FirstAsync_Predicate_Throw() { var scheduler = new TestScheduler(); @@ -200,7 +201,7 @@ public void FirstAsync_Predicate_Throw() ); } - [Fact] + [TestMethod] public void FirstAsync_PredicateThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultAsyncTest.cs index d2d4462b84..4103a4049b 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultAsyncTest.cs @@ -6,13 +6,14 @@ 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(() => Observable.FirstOrDefaultAsync(default(IObservable))); @@ -20,7 +21,7 @@ public void FirstOrDefaultAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FirstOrDefaultAsync(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_Empty() { var scheduler = new TestScheduler(); @@ -44,7 +45,7 @@ public void FirstOrDefaultAsync_Empty() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_One() { var scheduler = new TestScheduler(); @@ -69,7 +70,7 @@ public void FirstOrDefaultAsync_One() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_Many() { var scheduler = new TestScheduler(); @@ -95,7 +96,7 @@ public void FirstOrDefaultAsync_Many() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_Error() { var scheduler = new TestScheduler(); @@ -120,7 +121,7 @@ public void FirstOrDefaultAsync_Error() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_Predicate() { var scheduler = new TestScheduler(); @@ -150,7 +151,7 @@ public void FirstOrDefaultAsync_Predicate() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_Predicate_None() { var scheduler = new TestScheduler(); @@ -180,7 +181,7 @@ public void FirstOrDefaultAsync_Predicate_None() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_Predicate_Throw() { var scheduler = new TestScheduler(); @@ -206,7 +207,7 @@ public void FirstOrDefaultAsync_Predicate_Throw() ); } - [Fact] + [TestMethod] public void FirstOrDefaultAsync_PredicateThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultTest.cs index 65fd4061dd..f4dbe6723f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstOrDefaultTest.cs @@ -10,14 +10,17 @@ 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(() => Observable.FirstOrDefault(default(IObservable))); @@ -25,26 +28,26 @@ public void FirstOrDefault_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FirstOrDefault(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void FirstOrDefault_Empty() { Assert.Equal(default, Observable.Empty().FirstOrDefault()); } - [Fact] + [TestMethod] public void FirstOrDefaultPredicate_Empty() { Assert.Equal(default, Observable.Empty().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 @@ public void FirstOrDefault_Throw() ReactiveAssert.Throws(ex, () => xs.FirstOrDefault()); } - [Fact] + [TestMethod] public void FirstOrDefault_Range() { var value = 42; @@ -62,7 +65,7 @@ public void FirstOrDefault_Range() } #if !NO_THREAD - [Fact] + [TestMethod] public void FirstOrDefault_NoDoubleSet() { // diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstTest.cs index 6242b361e0..45a765b9d5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FirstTest.cs @@ -7,14 +7,17 @@ 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(() => Observable.First(default(IObservable))); @@ -22,40 +25,40 @@ public void First_ArgumentChecking() ReactiveAssert.Throws(() => Observable.First(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void First_Empty() { ReactiveAssert.Throws(() => Observable.Empty().First()); } - [Fact] + [TestMethod] public void FirstPredicate_Empty() { ReactiveAssert.Throws(() => Observable.Empty().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(() => Observable.Return(value).First(i => i % 2 != 0)); } - [Fact] + [TestMethod] public void First_Throw() { var ex = new Exception(); @@ -65,7 +68,7 @@ public void First_Throw() ReactiveAssert.Throws(ex, () => xs.First()); } - [Fact] + [TestMethod] public void FirstPredicate_Throw() { var ex = new Exception(); @@ -75,14 +78,14 @@ public void FirstPredicate_Throw() 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; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachAsyncTest.cs index c748cf5fd1..d1bd05c457 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachAsyncTest.cs @@ -10,14 +10,17 @@ 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(() => Observable.ForEachAsync(default(IObservable), x => { })); @@ -31,7 +34,7 @@ public void ForEachAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.ForEachAsync(Observable.Never(), default(Action), CancellationToken.None)); } - [Fact] + [TestMethod] public void ForEachAsync_Never() { var scheduler = new TestScheduler(); @@ -66,7 +69,7 @@ public void ForEachAsync_Never() Assert.Equal(TaskStatus.WaitingForActivation, task.Status); } - [Fact] + [TestMethod] public void ForEachAsync_Completed() { var scheduler = new TestScheduler(); @@ -102,7 +105,7 @@ public void ForEachAsync_Completed() Assert.Equal(TaskStatus.RanToCompletion, task.Status); } - [Fact] + [TestMethod] public void ForEachAsync_Error() { var scheduler = new TestScheduler(); @@ -141,7 +144,7 @@ public void ForEachAsync_Error() Assert.Same(exception, task.Exception.InnerException); } - [Fact] + [TestMethod] public void ForEachAsync_Throw() { var scheduler = new TestScheduler(); @@ -187,7 +190,7 @@ public void ForEachAsync_Throw() Assert.Same(exception, task.Exception.InnerException); } - [Fact] + [TestMethod] public void ForEachAsync_CancelDuring() { var scheduler = new TestScheduler(); @@ -222,7 +225,7 @@ public void ForEachAsync_CancelDuring() Assert.Equal(TaskStatus.Canceled, task.Status); } - [Fact] + [TestMethod] public void ForEachAsync_CancelBefore() { var scheduler = new TestScheduler(); @@ -255,7 +258,7 @@ public void ForEachAsync_CancelBefore() Assert.Equal(TaskStatus.Canceled, task.Status); } - [Fact] + [TestMethod] public void ForEachAsync_CancelAfter() { var scheduler = new TestScheduler(); @@ -292,7 +295,7 @@ public void ForEachAsync_CancelAfter() Assert.Equal(TaskStatus.RanToCompletion, task.Status); } - [Fact] + [TestMethod] public void ForEachAsync_Default() { var list = new List(); @@ -300,7 +303,7 @@ public void ForEachAsync_Default() list.AssertEqual(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } - [Fact] + [TestMethod] public void ForEachAsync_Index() { var list = new List(); @@ -308,7 +311,7 @@ public void ForEachAsync_Index() 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 @@ public void ForEachAsync_Default_Cancel() } } - [Fact] + [TestMethod] public void ForEachAsync_Index_Cancel() { var N = 10; @@ -426,7 +429,7 @@ public void ForEachAsync_Index_Cancel() } } - [Fact] + [TestMethod] public void ForEachAsync_DisposeThrows1() { var cts = new CancellationTokenSource(); @@ -464,7 +467,7 @@ public void ForEachAsync_DisposeThrows1() } } - [Fact] + [TestMethod] public void ForEachAsync_DisposeThrows2() { var cts = new CancellationTokenSource(); @@ -507,8 +510,8 @@ public void ForEachAsync_DisposeThrows2() } #if !NO_THREAD - [Fact] - [Trait("SkipCI", "true")] + [TestMethod] + [TestCategory("SkipCI")] public void ForEachAsync_DisposeThrows() { // @@ -561,7 +564,7 @@ public void ForEachAsync_DisposeThrows() } } - [Fact] + [TestMethod] public void ForEachAsync_SubscribeThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachTest.cs index 5fe93be6cc..658ecf1628 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForEachTest.cs @@ -7,14 +7,17 @@ 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(); @@ -26,7 +29,7 @@ public void ForEach_ArgumentChecking() ReactiveAssert.Throws(() => Observable.ForEach(someObservable, default(Action))); } - [Fact] + [TestMethod] public void ForEach_Empty() { var lst = new List(); @@ -34,7 +37,7 @@ public void ForEach_Empty() Assert.True(lst.SequenceEqual(Enumerable.Empty())); } - [Fact] + [TestMethod] public void ForEach_Index_Empty() { var lstX = new List(); @@ -42,7 +45,7 @@ public void ForEach_Index_Empty() Assert.True(lstX.SequenceEqual(Enumerable.Empty())); } - [Fact] + [TestMethod] public void ForEach_Return() { var lst = new List(); @@ -50,7 +53,7 @@ public void ForEach_Return() Assert.True(lst.SequenceEqual(new[] { 42 })); } - [Fact] + [TestMethod] public void ForEach_Index_Return() { var lstX = new List(); @@ -60,7 +63,7 @@ public void ForEach_Index_Return() Assert.True(lstI.SequenceEqual(new[] { 0 })); } - [Fact] + [TestMethod] public void ForEach_Throw() { var ex = new Exception(); @@ -70,7 +73,7 @@ public void ForEach_Throw() ReactiveAssert.Throws(ex, () => xs.ForEach(x => { Assert.True(false); })); } - [Fact] + [TestMethod] public void ForEach_Index_Throw() { var ex = new Exception(); @@ -80,7 +83,7 @@ public void ForEach_Index_Throw() ReactiveAssert.Throws(ex, () => xs.ForEach((x, i) => { Assert.True(false); })); } - [Fact] + [TestMethod] public void ForEach_SomeData() { var lstX = new List(); @@ -88,7 +91,7 @@ public void ForEach_SomeData() Assert.True(lstX.SequenceEqual(Enumerable.Range(10, 10))); } - [Fact] + [TestMethod] public void ForEach_Index_SomeData() { var lstX = new List(); @@ -98,7 +101,7 @@ public void ForEach_Index_SomeData() Assert.True(lstI.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void ForEach_OnNextThrows() { var ex = new Exception(); @@ -108,7 +111,7 @@ public void ForEach_OnNextThrows() ReactiveAssert.Throws(ex, () => xs.ForEach(x => { throw ex; })); } - [Fact] + [TestMethod] public void ForEach_Index_OnNextThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForTest.cs index 6abb982f57..1754a2d4c6 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForTest.cs @@ -7,21 +7,22 @@ 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(() => Observable.For(DummyEnumerable.Instance, default(Func>))); ReactiveAssert.Throws(() => Observable.For(null, DummyFunc>.Instance)); } - [Fact] + [TestMethod] public void For_Basic() { var scheduler = new TestScheduler(); @@ -54,7 +55,7 @@ private IEnumerable For_Error_Core(Exception ex) throw ex; } - [Fact] + [TestMethod] public void For_Error_Iterator() { var scheduler = new TestScheduler(); @@ -81,7 +82,7 @@ public void For_Error_Iterator() ); } - [Fact] + [TestMethod] public void For_Error_Source() { var scheduler = new TestScheduler(); @@ -95,7 +96,7 @@ public void For_Error_Source() ); } - [Fact] + [TestMethod] public void For_SelectorThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForkJoinTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForkJoinTest.cs index d2ef713d6b..403d8cefb5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForkJoinTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ForkJoinTest.cs @@ -8,14 +8,15 @@ 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.Instance; @@ -27,7 +28,7 @@ public void ForkJoin_ArgumentChecking() ReactiveAssert.Throws(() => ObservableEx.ForkJoin((IEnumerable>)null)); } - [Fact] + [TestMethod] public void ForkJoin_EmptyEmpty() { var scheduler = new TestScheduler(); @@ -51,7 +52,7 @@ public void ForkJoin_EmptyEmpty() ); } - [Fact] + [TestMethod] public void ForkJoin_None() { var scheduler = new TestScheduler(); @@ -62,7 +63,7 @@ public void ForkJoin_None() ); } - [Fact] + [TestMethod] public void ForkJoin_EmptyReturn() { var scheduler = new TestScheduler(); @@ -87,7 +88,7 @@ public void ForkJoin_EmptyReturn() ); } - [Fact] + [TestMethod] public void ForkJoin_ReturnEmpty() { var scheduler = new TestScheduler(); @@ -112,7 +113,7 @@ public void ForkJoin_ReturnEmpty() ); } - [Fact] + [TestMethod] public void ForkJoin_ReturnReturn() { var scheduler = new TestScheduler(); @@ -139,7 +140,7 @@ public void ForkJoin_ReturnReturn() ); } - [Fact] + [TestMethod] public void ForkJoin_EmptyThrow() { var ex = new Exception(); @@ -166,7 +167,7 @@ public void ForkJoin_EmptyThrow() ); } - [Fact] + [TestMethod] public void ForkJoin_ThrowEmpty() { var ex = new Exception(); @@ -193,7 +194,7 @@ public void ForkJoin_ThrowEmpty() ); } - [Fact] + [TestMethod] public void ForkJoin_ReturnThrow() { var ex = new Exception(); @@ -221,7 +222,7 @@ public void ForkJoin_ReturnThrow() ); } - [Fact] + [TestMethod] public void ForkJoin_ThrowReturn() { var ex = new Exception(); @@ -249,7 +250,7 @@ public void ForkJoin_ThrowReturn() ); } - [Fact] + [TestMethod] public void ForkJoin_Binary() { var scheduler = new TestScheduler(); @@ -278,7 +279,7 @@ public void ForkJoin_Binary() ); } - [Fact] + [TestMethod] public void ForkJoin_NaryParams() { var scheduler = new TestScheduler(); @@ -316,7 +317,7 @@ public void ForkJoin_NaryParams() ); } - [Fact] + [TestMethod] public void ForkJoin_NaryParamsEmpty() { var scheduler = new TestScheduler(); @@ -350,7 +351,7 @@ public void ForkJoin_NaryParamsEmpty() ); } - [Fact] + [TestMethod] public void ForkJoin_NaryParamsEmptyBeforeEnd() { var scheduler = new TestScheduler(); @@ -384,13 +385,13 @@ public void ForkJoin_NaryParamsEmptyBeforeEnd() ); } - [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 @@ public void ForkJoin_Nary_Virtual_And_Immediate() ); } - [Fact] + [TestMethod] public void ForkJoin_Nary_Immediate_And_Virtual() { var scheduler = new TestScheduler(); @@ -466,7 +467,7 @@ public void ForkJoin_Nary_Immediate_And_Virtual() ); } - [Fact] + [TestMethod] public void ForkJoin_Nary() { var scheduler = new TestScheduler(); @@ -504,7 +505,7 @@ public void ForkJoin_Nary() ); } - [Fact] + [TestMethod] public void Bug_1302_SelectorThrows_LeftLast() { var scheduler = new TestScheduler(); @@ -536,7 +537,7 @@ public void Bug_1302_SelectorThrows_LeftLast() ); } - [Fact] + [TestMethod] public void Bug_1302_SelectorThrows_RightLast() { var scheduler = new TestScheduler(); @@ -568,7 +569,7 @@ public void Bug_1302_SelectorThrows_RightLast() ); } - [Fact] + [TestMethod] public void Bug_1302_RightLast_NoLeft() { var scheduler = new TestScheduler(); @@ -597,7 +598,7 @@ public void Bug_1302_RightLast_NoLeft() ); } - [Fact] + [TestMethod] public void Bug_1302_RightLast_NoRight() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncPatternTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncPatternTest.cs index 9245bdce35..ce5d6edae2 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncPatternTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncPatternTest.cs @@ -8,11 +8,14 @@ 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 _doneTask; @@ -24,7 +27,7 @@ public FromAsyncPatternTest() _doneTask = tcs.Task; } - [Fact] + [TestMethod] public void FromAsyncPattern_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.FromAsyncPattern(null, iar => { })); @@ -90,7 +93,7 @@ public void FromAsyncPattern_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromAsyncPattern((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 @@ public void FromAsyncPattern0() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction0() { var x = new Result(); @@ -114,7 +117,7 @@ public void FromAsyncPatternAction0() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern0_Error() { var x = new Result(); @@ -127,7 +130,7 @@ public void FromAsyncPattern0_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern0_ErrorBegin() { var x = new Result(); @@ -140,7 +143,7 @@ public void FromAsyncPattern0_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern1() { var x = new Result(); @@ -157,7 +160,7 @@ public void FromAsyncPattern1() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction1() { var x = new Result(); @@ -174,7 +177,7 @@ public void FromAsyncPatternAction1() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern1_Error() { var x = new Result(); @@ -187,7 +190,7 @@ public void FromAsyncPattern1_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern1_ErrorBegin() { var x = new Result(); @@ -200,7 +203,7 @@ public void FromAsyncPattern1_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern2() { var x = new Result(); @@ -218,7 +221,7 @@ public void FromAsyncPattern2() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction2() { var x = new Result(); @@ -236,7 +239,7 @@ public void FromAsyncPatternAction2() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern2_Error() { var x = new Result(); @@ -249,7 +252,7 @@ public void FromAsyncPattern2_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern2_ErrorBegin() { var x = new Result(); @@ -262,7 +265,7 @@ public void FromAsyncPattern2_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern3() { var x = new Result(); @@ -280,7 +283,7 @@ public void FromAsyncPattern3() var res = Observable.FromAsyncPattern(begin, end)(2, 3, 4).Materialize().ToEnumerable().ToArray(); Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction3() { var x = new Result(); @@ -299,7 +302,7 @@ public void FromAsyncPatternAction3() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern3_Error() { var x = new Result(); @@ -312,7 +315,7 @@ public void FromAsyncPattern3_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern3_ErrorBegin() { var x = new Result(); @@ -325,7 +328,7 @@ public void FromAsyncPattern3_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern4() { var x = new Result(); @@ -345,7 +348,7 @@ public void FromAsyncPattern4() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction4() { var x = new Result(); @@ -365,7 +368,7 @@ public void FromAsyncPatternAction4() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern4_Error() { var x = new Result(); @@ -378,7 +381,7 @@ public void FromAsyncPattern4_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern4_ErrorBegin() { var x = new Result(); @@ -391,7 +394,7 @@ public void FromAsyncPattern4_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern5() { var x = new Result(); @@ -412,7 +415,7 @@ public void FromAsyncPattern5() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction5() { var x = new Result(); @@ -433,7 +436,7 @@ public void FromAsyncPatternAction5() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern5_Error() { var x = new Result(); @@ -446,7 +449,7 @@ public void FromAsyncPattern5_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern5_ErrorBegin() { var x = new Result(); @@ -459,7 +462,7 @@ public void FromAsyncPattern5_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern6() { var x = new Result(); @@ -481,7 +484,7 @@ public void FromAsyncPattern6() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction6() { var x = new Result(); @@ -503,7 +506,7 @@ public void FromAsyncPatternAction6() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern6_Error() { var x = new Result(); @@ -516,7 +519,7 @@ public void FromAsyncPattern6_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern6_ErrorBegin() { var x = new Result(); @@ -529,7 +532,7 @@ public void FromAsyncPattern6_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern7() { var x = new Result(); @@ -552,7 +555,7 @@ public void FromAsyncPattern7() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction7() { var x = new Result(); @@ -575,7 +578,7 @@ public void FromAsyncPatternAction7() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern7_Error() { var x = new Result(); @@ -588,7 +591,7 @@ public void FromAsyncPattern7_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern7_ErrorBegin() { var x = new Result(); @@ -601,7 +604,7 @@ public void FromAsyncPattern7_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern8() { var x = new Result(); @@ -625,7 +628,7 @@ public void FromAsyncPattern8() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction8() { var x = new Result(); @@ -649,7 +652,7 @@ public void FromAsyncPatternAction8() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern8_Error() { var x = new Result(); @@ -662,7 +665,7 @@ public void FromAsyncPattern8_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern8_ErrorBegin() { var x = new Result(); @@ -675,7 +678,7 @@ public void FromAsyncPattern8_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern9() { var x = new Result(); @@ -700,7 +703,7 @@ public void FromAsyncPattern9() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction9() { var x = new Result(); @@ -725,7 +728,7 @@ public void FromAsyncPatternAction9() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern9_Error() { var x = new Result(); @@ -738,7 +741,7 @@ public void FromAsyncPattern9_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern9_ErrorBegin() { var x = new Result(); @@ -751,7 +754,7 @@ public void FromAsyncPattern9_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern10() { var x = new Result(); @@ -777,7 +780,7 @@ public void FromAsyncPattern10() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction10() { var x = new Result(); @@ -803,7 +806,7 @@ public void FromAsyncPatternAction10() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern10_Error() { var x = new Result(); @@ -816,7 +819,7 @@ public void FromAsyncPattern10_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern10_ErrorBegin() { var x = new Result(); @@ -829,7 +832,7 @@ public void FromAsyncPattern10_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern11() { var x = new Result(); @@ -856,7 +859,7 @@ public void FromAsyncPattern11() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction11() { var x = new Result(); @@ -883,7 +886,7 @@ public void FromAsyncPatternAction11() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern11_Error() { var x = new Result(); @@ -896,7 +899,7 @@ public void FromAsyncPattern11_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern11_ErrorBegin() { var x = new Result(); @@ -909,7 +912,7 @@ public void FromAsyncPattern11_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern12() { var x = new Result(); @@ -937,7 +940,7 @@ public void FromAsyncPattern12() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction12() { var x = new Result(); @@ -965,7 +968,7 @@ public void FromAsyncPatternAction12() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern12_Error() { var x = new Result(); @@ -978,7 +981,7 @@ public void FromAsyncPattern12_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern12_ErrorBegin() { var x = new Result(); @@ -991,7 +994,7 @@ public void FromAsyncPattern12_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern13() { var x = new Result(); @@ -1020,7 +1023,7 @@ public void FromAsyncPattern13() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction13() { var x = new Result(); @@ -1049,7 +1052,7 @@ public void FromAsyncPatternAction13() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern13_Error() { var x = new Result(); @@ -1062,7 +1065,7 @@ public void FromAsyncPattern13_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern13_ErrorBegin() { var x = new Result(); @@ -1075,7 +1078,7 @@ public void FromAsyncPattern13_ErrorBegin() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern14() { var x = new Result(); @@ -1105,7 +1108,7 @@ public void FromAsyncPattern14() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnNext(1), Notification.CreateOnCompleted() })); } - [Fact] + [TestMethod] public void FromAsyncPatternAction14() { var x = new Result(); @@ -1135,7 +1138,7 @@ public void FromAsyncPatternAction14() Assert.True(res.SequenceEqual(new[] { new Unit() })); } - [Fact] + [TestMethod] public void FromAsyncPattern14_Error() { var x = new Result(); @@ -1148,7 +1151,7 @@ public void FromAsyncPattern14_Error() Assert.True(res.SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void FromAsyncPattern14_ErrorBegin() { var x = new Result(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncTest.cs index ff10b80a1c..2a3473a03d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromAsyncTest.cs @@ -10,10 +10,13 @@ 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 _doneTask; @@ -27,7 +30,7 @@ public FromAsyncTest() #region Func - [Fact] + [TestMethod] public void FromAsync_Func_ArgumentChecking() { var s = Scheduler.Immediate; @@ -41,7 +44,7 @@ public void FromAsync_Func_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromAsync(ct => _doneTask, default)); } - [Fact] + [TestMethod] public void FromAsync_Func_Success() { var n = 42; @@ -60,7 +63,7 @@ public void FromAsync_Func_Success() Assert.Equal(2, i); } - [Fact] + [TestMethod] public void FromAsync_Func_Throw_Synchronous() { var ex = new Exception(); @@ -73,7 +76,7 @@ public void FromAsync_Func_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_Func_Throw_Asynchronous() { var ex = new Exception(); @@ -85,7 +88,7 @@ public void FromAsync_Func_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_FuncWithCancel_Success() { var n = 42; @@ -104,7 +107,7 @@ public void FromAsync_FuncWithCancel_Success() Assert.Equal(2, i); } - [Fact] + [TestMethod] public void FromAsync_FuncWithCancel_Throw_Synchronous() { var ex = new Exception(); @@ -117,7 +120,7 @@ public void FromAsync_FuncWithCancel_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_FuncWithCancel_Throw_Asynchronous() { var ex = new Exception(); @@ -129,7 +132,7 @@ public void FromAsync_FuncWithCancel_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_FuncWithCancel_Cancel() { var e = new ManualResetEvent(false); @@ -166,7 +169,7 @@ public void FromAsync_FuncWithCancel_Cancel() } #if DESKTOPCLR - [Fact] + [TestMethod] public void FromAsync_Func_Scheduler1() { var e = new ManualResetEvent(false); @@ -191,7 +194,7 @@ public void FromAsync_Func_Scheduler1() Assert.Equal(Thread.CurrentThread.ManagedThreadId, t); } - [Fact] + [TestMethod] public void FromAsync_Func_Scheduler2() { var e = new ManualResetEvent(false); @@ -221,7 +224,7 @@ public void FromAsync_Func_Scheduler2() #region Action - [Fact] + [TestMethod] public void FromAsync_Action_ArgumentChecking() { var s = Scheduler.Immediate; @@ -235,7 +238,7 @@ public void FromAsync_Action_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromAsync(ct => (Task)_doneTask, default)); } - [Fact] + [TestMethod] public void FromAsync_Action_Success() { var i = 0; @@ -252,7 +255,7 @@ public void FromAsync_Action_Success() Assert.Equal(2, i); } - [Fact] + [TestMethod] public void FromAsync_Action_Throw_Synchronous() { var ex = new Exception(); @@ -265,7 +268,7 @@ public void FromAsync_Action_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_Action_Throw_Asynchronous() { var ex = new Exception(); @@ -277,7 +280,7 @@ public void FromAsync_Action_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_ActionWithCancel_Success() { var i = 0; @@ -294,7 +297,7 @@ public void FromAsync_ActionWithCancel_Success() Assert.Equal(2, i); } - [Fact] + [TestMethod] public void FromAsync_ActionWithCancel_Throw_Synchronous() { var ex = new Exception(); @@ -307,7 +310,7 @@ public void FromAsync_ActionWithCancel_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_ActionWithCancel_Throw_Asynchronous() { var ex = new Exception(); @@ -319,7 +322,7 @@ public void FromAsync_ActionWithCancel_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void FromAsync_ActionWithCancel_Cancel() { var e = new ManualResetEvent(false); @@ -356,7 +359,7 @@ public void FromAsync_ActionWithCancel_Cancel() } #if DESKTOPCLR - [Fact] + [TestMethod] public void FromAsync_Action_Scheduler1() { var e = new ManualResetEvent(false); @@ -378,7 +381,7 @@ public void FromAsync_Action_Scheduler1() Assert.Equal(Thread.CurrentThread.ManagedThreadId, t); } - [Fact] + [TestMethod] public void FromAsync_Action_Scheduler2() { var e = new ManualResetEvent(false); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventPatternTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventPatternTest.cs index bba07c3682..9ba64a7c86 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventPatternTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventPatternTest.cs @@ -13,16 +13,19 @@ 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(() => Observable.FromEventPattern(null, h => { })); @@ -42,7 +45,7 @@ public void FromEventPattern_Conversion_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromEventPattern(h => new EventHandler(h), h => { }, h => { }, default)); } - [Fact] + [TestMethod] public void FromEventPattern_E2() { var scheduler = new TestScheduler(); @@ -69,7 +72,7 @@ public void FromEventPattern_E2() ); } - [Fact] + [TestMethod] public void FromEventPattern_Conversion_E4() { var scheduler = new TestScheduler(); @@ -97,7 +100,7 @@ public void FromEventPattern_Conversion_E4() ); } - [Fact] + [TestMethod] public void FromEventPattern_Conversion_E5() { var scheduler = new TestScheduler(); @@ -124,7 +127,7 @@ public void FromEventPattern_Conversion_E5() ); } - [Fact] + [TestMethod] public void FromEventPattern_ConversionThrows() { var ex = new Exception(); @@ -144,7 +147,7 @@ public void FromEventPattern_ConversionThrows() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void FromEventPattern_E2_WithSender() { var scheduler = new TestScheduler(); @@ -171,7 +174,7 @@ public void FromEventPattern_E2_WithSender() ); } - [Fact] + [TestMethod] public void FromEventPattern_AddRemove_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.FromEventPattern(null, h => { })); @@ -196,7 +199,7 @@ public void FromEventPattern_AddRemove_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromEventPattern(h => { }, h => { }, default)); } - [Fact] + [TestMethod] public void FromEventPattern_AddRemove_E4() { var scheduler = new TestScheduler(); @@ -229,7 +232,7 @@ public void FromEventPattern_AddRemove_E4() #region Instance events - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.FromEventPattern(default(object), "foo")); @@ -269,13 +272,13 @@ public void FromEventPattern_Reflection_Instance_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromEventPattern(new FromEventPattern_ArgCheck(), "foo")); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_InvalidVariance() { ReactiveAssert.Throws(() => Observable.FromEventPattern(new FromEventPattern_VarianceCheck(), "E1")); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_VarianceArgs() { var src = new FromEventPattern_VarianceCheck(); @@ -299,7 +302,7 @@ public void FromEventPattern_Reflection_Instance_VarianceArgs() 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 @@ public void FromEventPattern_Reflection_Instance_VarianceSender() 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 @@ public void FromEventPattern_Reflection_Instance_NonGeneric() Assert.True(ReferenceEquals(e2, lst[1].EventArgs), "Second"); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_Throws() { // @@ -374,7 +377,7 @@ public void FromEventPattern_Reflection_Instance_Throws() ReactiveAssert.Throws(d.Dispose); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_E1() { var scheduler = new TestScheduler(); @@ -399,7 +402,7 @@ public void FromEventPattern_Reflection_Instance_E1() ); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_E2() { var scheduler = new TestScheduler(); @@ -424,7 +427,7 @@ public void FromEventPattern_Reflection_Instance_E2() ); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_E2_WithSender() { var scheduler = new TestScheduler(); @@ -449,7 +452,7 @@ public void FromEventPattern_Reflection_Instance_E2_WithSender() ); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Instance_E3() { var scheduler = new TestScheduler(); @@ -475,7 +478,7 @@ public void FromEventPattern_Reflection_Instance_E3() } #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 @@ public void FromEventPattern_Reflection_Instance_MissingAccessors() #region Static events - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Static_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.FromEventPattern(default, "foo")); @@ -536,7 +539,7 @@ public void FromEventPattern_Reflection_Static_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromEventPattern(typeof(FromEventPattern_ArgCheck), "foo")); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Static_E6() { var scheduler = new TestScheduler(); @@ -559,7 +562,7 @@ public void FromEventPattern_Reflection_Static_E6() ); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Static_E6_WithSender() { var scheduler = new TestScheduler(); @@ -582,7 +585,7 @@ public void FromEventPattern_Reflection_Static_E6_WithSender() ); } - [Fact] + [TestMethod] public void FromEventPattern_Reflection_Static_NonGeneric_E6() { var scheduler = new TestScheduler(); @@ -612,13 +615,13 @@ public void FromEventPattern_Reflection_Static_NonGeneric_E6() #region Rx v2.0 behavior - [Fact] + [TestMethod] public void FromEventPattern_Scheduler1() { RunWithScheduler((s, add, remove) => Observable.FromEventPattern(h => { add(); }, h => { remove(); }, s)); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler2() { RunWithScheduler((s, add, remove) => @@ -629,7 +632,7 @@ public void FromEventPattern_Scheduler2() }); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler3() { RunWithScheduler((s, add, remove) => @@ -640,13 +643,13 @@ public void FromEventPattern_Scheduler3() }); } - [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 @@ public void FromEventPattern_Scheduler5() }); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler6() { RunWithScheduler((s, add, remove) => @@ -668,19 +671,19 @@ public void FromEventPattern_Scheduler6() }); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler7() { RunWithScheduler((s, add, remove) => Observable.FromEventPattern, MyEventArgs>(h => { add(); }, h => { remove(); }, s)); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler8() { RunWithScheduler((s, add, remove) => Observable.FromEventPattern, MyEventArgs>(h => h, h => { add(); }, h => { remove(); }, s)); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler9() { RunWithScheduler((s, add, remove) => @@ -691,7 +694,7 @@ public void FromEventPattern_Scheduler9() }); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler10() { RunWithScheduler((s, add, remove) => @@ -702,7 +705,7 @@ public void FromEventPattern_Scheduler10() }); } - [Fact] + [TestMethod] public void FromEventPattern_Scheduler11() { RunWithScheduler((s, add, remove) => Observable.FromEventPattern, object, MyEventArgs>(h => { add(); }, h => { remove(); }, s)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventTest.cs index c62e15e86a..d242429662 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/FromEventTest.cs @@ -9,14 +9,17 @@ 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(() => Observable.FromEvent, int>(default, h => { }, h => { })); @@ -50,7 +53,7 @@ public void FromEvent_ArgumentChecking() ReactiveAssert.Throws(() => Observable.FromEvent(h => { }, h => { }, default)); } - [Fact] + [TestMethod] public void FromEvent_Action() { var fe = new FromEvent(); @@ -72,7 +75,7 @@ public void FromEvent_Action() Assert.Equal(2, n); } - [Fact] + [TestMethod] public void FromEvent_ActionOfInt() { var fe = new FromEvent(); @@ -94,7 +97,7 @@ public void FromEvent_ActionOfInt() Assert.Equal(2 + 3, n); } - [Fact] + [TestMethod] public void FromEvent_ActionOfInt_SpecifiedExplicitly() { var fe = new FromEvent(); @@ -116,7 +119,7 @@ public void FromEvent_ActionOfInt_SpecifiedExplicitly() Assert.Equal(2 + 3, n); } - [Fact] + [TestMethod] public void FromEvent_ActionOfInt_SpecifiedExplicitly_TrivialConversion() { var fe = new FromEvent(); @@ -138,7 +141,7 @@ public void FromEvent_ActionOfInt_SpecifiedExplicitly_TrivialConversion() Assert.Equal(2 + 3, n); } - [Fact] + [TestMethod] public void FromEvent_MyAction() { var fe = new FromEvent(); @@ -162,7 +165,7 @@ public void FromEvent_MyAction() #region Rx v2.0 behavior - [Fact] + [TestMethod] public void FromEvent_ImplicitPublish() { var src = new MyEventSource(); @@ -238,7 +241,7 @@ public void FromEvent_ImplicitPublish() Assert.True(thd.SequenceEqual(new[] { 44, 45 })); } #if !NO_THREAD - [Fact] + [TestMethod] public void FromEvent_SynchronizationContext() { var beforeSubscribeNull = false; @@ -336,25 +339,25 @@ private void RunWithContext(T ctx, Action run) } #endif - [Fact] + [TestMethod] public void FromEvent_Scheduler1() { RunWithScheduler((s, add, remove) => Observable.FromEvent(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, MyEventArgs>(h => { add(); }, h => { remove(); }, s)); } - [Fact] + [TestMethod] public void FromEvent_Scheduler4() { RunWithScheduler((s, add, remove) => Observable.FromEvent(h => () => { }, h => { add(); }, h => { remove(); }, s)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GenerateTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GenerateTest.cs index e55260e8ae..753188d94c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GenerateTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GenerateTest.cs @@ -12,15 +12,18 @@ 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(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, (IScheduler)null)); @@ -30,7 +33,7 @@ public void Generate_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Generate_Finite() { var scheduler = new TestScheduler(); @@ -48,7 +51,7 @@ public void Generate_Finite() ); } - [Fact] + [TestMethod] public void Generate_Throw_Condition() { var scheduler = new TestScheduler(); @@ -64,7 +67,7 @@ public void Generate_Throw_Condition() ); } - [Fact] + [TestMethod] public void Generate_Throw_ResultSelector() { var scheduler = new TestScheduler(); @@ -80,7 +83,7 @@ public void Generate_Throw_ResultSelector() ); } - [Fact] + [TestMethod] public void Generate_Throw_Iterate() { var scheduler = new TestScheduler(); @@ -97,7 +100,7 @@ public void Generate_Throw_Iterate() ); } - [Fact] + [TestMethod] public void Generate_Dispose() { var scheduler = new TestScheduler(); @@ -113,7 +116,7 @@ public void Generate_Dispose() ); } - [Fact] + [TestMethod] public void Generate_DefaultScheduler_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Generate(0, null, DummyFunc.Instance, DummyFunc.Instance)); @@ -122,14 +125,14 @@ public void Generate_DefaultScheduler_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.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 @@ public void Generate_LongRunning1() Assert.True(done); } - [Fact] + [TestMethod] [MethodImpl(MethodImplOptions.NoOptimization)] public void Generate_LongRunning2() { @@ -174,7 +177,7 @@ public void Generate_LongRunning2() 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 @@ public void Generate_LongRunning_Throw() #region + Timed + - [Fact] + [TestMethod] public void Generate_TimeSpan_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, null)); @@ -212,7 +215,7 @@ public void Generate_TimeSpan_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Generate_TimeSpan_Finite() { var scheduler = new TestScheduler(); @@ -230,7 +233,7 @@ public void Generate_TimeSpan_Finite() ); } - [Fact] + [TestMethod] public void Generate_TimeSpan_Throw_Condition() { var scheduler = new TestScheduler(); @@ -246,7 +249,7 @@ public void Generate_TimeSpan_Throw_Condition() ); } - [Fact] + [TestMethod] public void Generate_TimeSpan_Throw_ResultSelector() { var scheduler = new TestScheduler(); @@ -262,7 +265,7 @@ public void Generate_TimeSpan_Throw_ResultSelector() ); } - [Fact] + [TestMethod] public void Generate_TimeSpan_Throw_Iterate() { var scheduler = new TestScheduler(); @@ -279,7 +282,7 @@ public void Generate_TimeSpan_Throw_Iterate() ); } - [Fact] + [TestMethod] public void Generate_TimeSpan_Throw_TimeSelector() { var scheduler = new TestScheduler(); @@ -295,7 +298,7 @@ public void Generate_TimeSpan_Throw_TimeSelector() ); } - [Fact] + [TestMethod] public void Generate_TimeSpan_Dispose() { var scheduler = new TestScheduler(); @@ -312,7 +315,7 @@ public void Generate_TimeSpan_Dispose() ); } - [Fact] + [TestMethod] public void Generate_TimeSpan_DefaultScheduler_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Generate(0, null, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance)); @@ -322,13 +325,13 @@ public void Generate_TimeSpan_DefaultScheduler_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.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(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, null)); @@ -339,7 +342,7 @@ public void Generate_DateTimeOffset_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_Finite() { var scheduler = new TestScheduler(); @@ -357,7 +360,7 @@ public void Generate_DateTimeOffset_Finite() ); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_Throw_Condition() { var scheduler = new TestScheduler(); @@ -373,7 +376,7 @@ public void Generate_DateTimeOffset_Throw_Condition() ); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_Throw_ResultSelector() { var scheduler = new TestScheduler(); @@ -389,7 +392,7 @@ public void Generate_DateTimeOffset_Throw_ResultSelector() ); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_Throw_Iterate() { var scheduler = new TestScheduler(); @@ -406,7 +409,7 @@ public void Generate_DateTimeOffset_Throw_Iterate() ); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_Throw_TimeSelector() { var scheduler = new TestScheduler(); @@ -422,7 +425,7 @@ public void Generate_DateTimeOffset_Throw_TimeSelector() ); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_Dispose() { var scheduler = new TestScheduler(); @@ -439,7 +442,7 @@ public void Generate_DateTimeOffset_Dispose() ); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_DefaultScheduler_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Generate(0, null, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance)); @@ -449,13 +452,13 @@ public void Generate_DateTimeOffset_DefaultScheduler_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Generate(0, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.Instance, DummyFunc.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 @@ public void Generate_TimeSpan_DisposeLater() d.Dispose(); } - [Fact] + [TestMethod] public void Generate_DateTimeOffset_DisposeLater() { var count = 0; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GetEnumeratorTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GetEnumeratorTest.cs index 992f0175bf..f6be5165da 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GetEnumeratorTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GetEnumeratorTest.cs @@ -9,20 +9,23 @@ 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(() => Observable.GetEnumerator(default(IObservable))); } - [Fact] + [TestMethod] public void GetEnumerator_Regular1() { var scheduler = new TestScheduler(); @@ -74,7 +77,7 @@ public void GetEnumerator_Regular1() Assert.True(vals[3].Item1 == 230 && vals[3].Item2 == 7); } - [Fact] + [TestMethod] public void GetEnumerator_Regular2() { var scheduler = new TestScheduler(); @@ -126,7 +129,7 @@ public void GetEnumerator_Regular2() Assert.True(vals[3].Item1 == 180 && vals[3].Item2 == 7); } - [Fact] + [TestMethod] public void GetEnumerator_Dispose() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByTest.cs index 0a0d05d0de..6754d93f85 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByTest.cs @@ -10,15 +10,18 @@ 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(() => ((IObservable)null).GroupBy(DummyFunc.Instance, DummyFunc.Instance, EqualityComparer.Default)); @@ -28,7 +31,7 @@ public void GroupBy_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, DummyFunc.Instance, EqualityComparer.Default).Subscribe(null)); } - [Fact] + [TestMethod] public void GroupBy_KeyEle_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance, DummyFunc.Instance)); @@ -37,7 +40,7 @@ public void GroupBy_KeyEle_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void GroupBy_KeyComparer_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance, EqualityComparer.Default)); @@ -46,7 +49,7 @@ public void GroupBy_KeyComparer_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, EqualityComparer.Default).Subscribe(null)); } - [Fact] + [TestMethod] public void GroupBy_Key_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance)); @@ -54,7 +57,7 @@ public void GroupBy_Key_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void GroupBy_WithKeyComparer() { var scheduler = new TestScheduler(); @@ -108,7 +111,7 @@ public void GroupBy_WithKeyComparer() Assert.Equal(12, keyInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_Complete() { var scheduler = new TestScheduler(); @@ -172,7 +175,7 @@ public void GroupBy_Outer_Complete() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_Error() { var scheduler = new TestScheduler(); @@ -237,7 +240,7 @@ public void GroupBy_Outer_Error() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_Dispose() { var scheduler = new TestScheduler(); @@ -298,7 +301,7 @@ public void GroupBy_Outer_Dispose() Assert.Equal(5, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_KeyThrow() { var scheduler = new TestScheduler(); @@ -368,7 +371,7 @@ public void GroupBy_Outer_KeyThrow() Assert.Equal(9, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_EleThrow() { var scheduler = new TestScheduler(); @@ -438,7 +441,7 @@ public void GroupBy_Outer_EleThrow() Assert.Equal(10, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_ComparerEqualsThrow() { var scheduler = new TestScheduler(); @@ -500,7 +503,7 @@ public void GroupBy_Outer_ComparerEqualsThrow() Assert.Equal(3, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Outer_ComparerGetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -564,7 +567,7 @@ public void GroupBy_Outer_ComparerGetHashCodeThrow() Assert.Equal(7, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Inner_Complete() { var scheduler = new TestScheduler(); @@ -648,7 +651,7 @@ public void GroupBy_Inner_Complete() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Complete_All() { var scheduler = new TestScheduler(); @@ -738,7 +741,7 @@ public void GroupBy_Inner_Complete_All() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Error() { var scheduler = new TestScheduler(); @@ -824,7 +827,7 @@ public void GroupBy_Inner_Error() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Dispose() { var scheduler = new TestScheduler(); @@ -905,7 +908,7 @@ public void GroupBy_Inner_Dispose() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_KeyThrow() { var scheduler = new TestScheduler(); @@ -997,7 +1000,7 @@ public void GroupBy_Inner_KeyThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_EleThrow() { var scheduler = new TestScheduler(); @@ -1093,7 +1096,7 @@ public void GroupBy_Inner_EleThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Comparer_EqualsThrow() { var scheduler = new TestScheduler(); @@ -1178,7 +1181,7 @@ public void GroupBy_Inner_Comparer_EqualsThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Comparer_GetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -1263,7 +1266,7 @@ public void GroupBy_Inner_Comparer_GetHashCodeThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Outer_Independence() { var scheduler = new TestScheduler(); @@ -1350,7 +1353,7 @@ public void GroupBy_Outer_Independence() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Independence() { var scheduler = new TestScheduler(); @@ -1441,7 +1444,7 @@ public void GroupBy_Inner_Independence() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Multiple_Independence() { var scheduler = new TestScheduler(); @@ -1528,7 +1531,7 @@ public void GroupBy_Inner_Multiple_Independence() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Escape_Complete() { var scheduler = new TestScheduler(); @@ -1574,7 +1577,7 @@ public void GroupBy_Inner_Escape_Complete() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Escape_Error() { var scheduler = new TestScheduler(); @@ -1622,7 +1625,7 @@ public void GroupBy_Inner_Escape_Error() ); } - [Fact] + [TestMethod] public void GroupBy_Inner_Escape_Dispose() { var scheduler = new TestScheduler(); @@ -1668,7 +1671,7 @@ public void GroupBy_Inner_Escape_Dispose() ); } - [Fact] + [TestMethod] public void GroupBy_NullKeys_Simple() { var scheduler = new TestScheduler(); @@ -1696,7 +1699,7 @@ public void GroupBy_NullKeys_Simple() ); } - [Fact] + [TestMethod] public void GroupBy_NullKeys_Error() { var scheduler = new TestScheduler(); @@ -1748,7 +1751,7 @@ private static string Reverse(string s) private const int _groupByCapacity = 1024; - [Fact] + [TestMethod] public void GroupBy_Capacity_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance, DummyFunc.Instance, _groupByCapacity, EqualityComparer.Default)); @@ -1760,7 +1763,7 @@ public void GroupBy_Capacity_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, DummyFunc.Instance, -1, EqualityComparer.Default)); } - [Fact] + [TestMethod] public void GroupBy_Capacity_KeyEle_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance, DummyFunc.Instance, _groupByCapacity)); @@ -1771,7 +1774,7 @@ public void GroupBy_Capacity_KeyEle_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, DummyFunc.Instance, -1)); } - [Fact] + [TestMethod] public void GroupBy_Capacity_KeyComparer_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance, _groupByCapacity, EqualityComparer.Default)); @@ -1782,7 +1785,7 @@ public void GroupBy_Capacity_KeyComparer_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, -1, EqualityComparer.Default)); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Key_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).GroupBy(DummyFunc.Instance, _groupByCapacity)); @@ -1792,7 +1795,7 @@ public void GroupBy_Capacity_Key_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.GroupBy(DummyFunc.Instance, -1)); } - [Fact] + [TestMethod] public void GroupBy_Capacity_WithKeyComparer() { var scheduler = new TestScheduler(); @@ -1846,7 +1849,7 @@ public void GroupBy_Capacity_WithKeyComparer() Assert.Equal(12, keyInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_Complete() { var scheduler = new TestScheduler(); @@ -1911,7 +1914,7 @@ public void GroupBy_Capacity_Outer_Complete() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_Error() { var scheduler = new TestScheduler(); @@ -1977,7 +1980,7 @@ public void GroupBy_Capacity_Outer_Error() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_Dispose() { var scheduler = new TestScheduler(); @@ -2038,7 +2041,7 @@ public void GroupBy_Capacity_Outer_Dispose() Assert.Equal(5, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_KeyThrow() { var scheduler = new TestScheduler(); @@ -2109,7 +2112,7 @@ public void GroupBy_Capacity_Outer_KeyThrow() Assert.Equal(9, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_EleThrow() { var scheduler = new TestScheduler(); @@ -2180,7 +2183,7 @@ public void GroupBy_Capacity_Outer_EleThrow() Assert.Equal(10, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_ComparerEqualsThrow() { var scheduler = new TestScheduler(); @@ -2243,7 +2246,7 @@ public void GroupBy_Capacity_Outer_ComparerEqualsThrow() Assert.Equal(3, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_ComparerGetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -2308,7 +2311,7 @@ public void GroupBy_Capacity_Outer_ComparerGetHashCodeThrow() Assert.Equal(7, eleInvoked); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Complete() { var scheduler = new TestScheduler(); @@ -2392,7 +2395,7 @@ public void GroupBy_Capacity_Inner_Complete() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Complete_All() { var scheduler = new TestScheduler(); @@ -2482,7 +2485,7 @@ public void GroupBy_Capacity_Inner_Complete_All() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Error() { var scheduler = new TestScheduler(); @@ -2568,7 +2571,7 @@ public void GroupBy_Capacity_Inner_Error() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Dispose() { var scheduler = new TestScheduler(); @@ -2649,7 +2652,7 @@ public void GroupBy_Capacity_Inner_Dispose() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_KeyThrow() { var scheduler = new TestScheduler(); @@ -2741,7 +2744,7 @@ public void GroupBy_Capacity_Inner_KeyThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_EleThrow() { var scheduler = new TestScheduler(); @@ -2837,7 +2840,7 @@ public void GroupBy_Capacity_Inner_EleThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Comparer_EqualsThrow() { var scheduler = new TestScheduler(); @@ -2922,7 +2925,7 @@ public void GroupBy_Capacity_Inner_Comparer_EqualsThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Comparer_GetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -3007,7 +3010,7 @@ public void GroupBy_Capacity_Inner_Comparer_GetHashCodeThrow() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Outer_Independence() { var scheduler = new TestScheduler(); @@ -3094,7 +3097,7 @@ public void GroupBy_Capacity_Outer_Independence() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Independence() { var scheduler = new TestScheduler(); @@ -3185,7 +3188,7 @@ public void GroupBy_Capacity_Inner_Independence() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Multiple_Independence() { var scheduler = new TestScheduler(); @@ -3272,7 +3275,7 @@ public void GroupBy_Capacity_Inner_Multiple_Independence() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Escape_Complete() { var scheduler = new TestScheduler(); @@ -3318,7 +3321,7 @@ public void GroupBy_Capacity_Inner_Escape_Complete() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Escape_Error() { var scheduler = new TestScheduler(); @@ -3366,7 +3369,7 @@ public void GroupBy_Capacity_Inner_Escape_Error() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_Inner_Escape_Dispose() { var scheduler = new TestScheduler(); @@ -3412,7 +3415,7 @@ public void GroupBy_Capacity_Inner_Escape_Dispose() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_NullKeys_Simple() { var scheduler = new TestScheduler(); @@ -3440,7 +3443,7 @@ public void GroupBy_Capacity_NullKeys_Simple() ); } - [Fact] + [TestMethod] public void GroupBy_Capacity_NullKeys_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByUntilTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByUntilTest.cs index 0903f3d8fc..86ecee32d7 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByUntilTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupByUntilTest.cs @@ -11,15 +11,18 @@ 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 GroupByUntilTest : ReactiveTest { #region + GroupByUntil + - [Fact] + [TestMethod] public void GroupByUntil_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.GroupByUntil(default, DummyFunc.Instance, DummyFunc.Instance, DummyFunc, IObservable>.Instance, EqualityComparer.Default)); @@ -43,7 +46,7 @@ public void GroupByUntil_ArgumentChecking() ReactiveAssert.Throws(() => Observable.GroupByUntil(DummyObservable.Instance, DummyFunc.Instance, default(Func, IObservable>))); } - [Fact] + [TestMethod] public void GroupByUntil_WithKeyComparer() { var scheduler = new TestScheduler(); @@ -102,7 +105,7 @@ public void GroupByUntil_WithKeyComparer() Assert.Equal(12, keyInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_Complete() { var scheduler = new TestScheduler(); @@ -168,7 +171,7 @@ public void GroupByUntil_Outer_Complete() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_Error() { var scheduler = new TestScheduler(); @@ -235,7 +238,7 @@ public void GroupByUntil_Outer_Error() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_Dispose() { var scheduler = new TestScheduler(); @@ -299,7 +302,7 @@ public void GroupByUntil_Outer_Dispose() Assert.Equal(5, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_KeyThrow() { var scheduler = new TestScheduler(); @@ -371,7 +374,7 @@ public void GroupByUntil_Outer_KeyThrow() Assert.Equal(9, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_EleThrow() { var scheduler = new TestScheduler(); @@ -443,7 +446,7 @@ public void GroupByUntil_Outer_EleThrow() Assert.Equal(10, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_ComparerEqualsThrow() { var scheduler = new TestScheduler(); @@ -506,7 +509,7 @@ public void GroupByUntil_Outer_ComparerEqualsThrow() Assert.Equal(3, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_ComparerGetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -571,7 +574,7 @@ public void GroupByUntil_Outer_ComparerGetHashCodeThrow() Assert.Equal(7, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Complete() { var scheduler = new TestScheduler(); @@ -657,7 +660,7 @@ public void GroupByUntil_Inner_Complete() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Complete_All() { var scheduler = new TestScheduler(); @@ -751,7 +754,7 @@ public void GroupByUntil_Inner_Complete_All() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Error() { var scheduler = new TestScheduler(); @@ -839,7 +842,7 @@ public void GroupByUntil_Inner_Error() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Dispose() { var scheduler = new TestScheduler(); @@ -921,7 +924,7 @@ public void GroupByUntil_Inner_Dispose() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_KeyThrow() { var scheduler = new TestScheduler(); @@ -1012,7 +1015,7 @@ public void GroupByUntil_Inner_KeyThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_EleThrow() { var scheduler = new TestScheduler(); @@ -1107,7 +1110,7 @@ public void GroupByUntil_Inner_EleThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Comparer_EqualsThrow() { var scheduler = new TestScheduler(); @@ -1192,7 +1195,7 @@ public void GroupByUntil_Inner_Comparer_EqualsThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Comparer_GetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -1277,7 +1280,7 @@ public void GroupByUntil_Inner_Comparer_GetHashCodeThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Outer_Independence() { var scheduler = new TestScheduler(); @@ -1362,7 +1365,7 @@ public void GroupByUntil_Outer_Independence() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Independence() { var scheduler = new TestScheduler(); @@ -1460,7 +1463,7 @@ public void GroupByUntil_Inner_Independence() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Multiple_Independence() { var scheduler = new TestScheduler(); @@ -1554,7 +1557,7 @@ public void GroupByUntil_Inner_Multiple_Independence() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Escape_Complete() { var scheduler = new TestScheduler(); @@ -1600,7 +1603,7 @@ public void GroupByUntil_Inner_Escape_Complete() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Escape_Error() { var scheduler = new TestScheduler(); @@ -1648,7 +1651,7 @@ public void GroupByUntil_Inner_Escape_Error() ); } - [Fact] + [TestMethod] public void GroupByUntil_Inner_Escape_Dispose() { var scheduler = new TestScheduler(); @@ -1694,7 +1697,7 @@ public void GroupByUntil_Inner_Escape_Dispose() ); } - [Fact] + [TestMethod] public void GroupByUntil_Default() { var scheduler = new TestScheduler(); @@ -1757,7 +1760,7 @@ public void GroupByUntil_Default() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_DurationSelector_Throws() { var scheduler = new TestScheduler(); @@ -1781,7 +1784,7 @@ public void GroupByUntil_DurationSelector_Throws() ); } - [Fact] + [TestMethod] public void GroupByUntil_NullKeys_Simple_Never() { var scheduler = new TestScheduler(); @@ -1809,7 +1812,7 @@ public void GroupByUntil_NullKeys_Simple_Never() ); } - [Fact] + [TestMethod] public void GroupByUntil_NullKeys_Simple_Expire1() { var scheduler = new TestScheduler(); @@ -1840,7 +1843,7 @@ public void GroupByUntil_NullKeys_Simple_Expire1() ); } - [Fact] + [TestMethod] public void GroupByUntil_NullKeys_Simple_Expire2() { var scheduler = new TestScheduler(); @@ -1871,7 +1874,7 @@ public void GroupByUntil_NullKeys_Simple_Expire2() ); } - [Fact] + [TestMethod] public void GroupByUntil_NullKeys_Error() { var scheduler = new TestScheduler(); @@ -1911,7 +1914,7 @@ public void GroupByUntil_NullKeys_Error() private const int _groupByUntilCapacity = 1024; - [Fact] + [TestMethod] public void GroupByUntil_Capacity_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.GroupByUntil(default, DummyFunc.Instance, DummyFunc.Instance, DummyFunc, IObservable>.Instance, _groupByUntilCapacity, EqualityComparer.Default)); @@ -1940,7 +1943,7 @@ public void GroupByUntil_Capacity_ArgumentChecking() ReactiveAssert.Throws(() => Observable.GroupByUntil(DummyObservable.Instance, DummyFunc.Instance, DummyFunc, IObservable>.Instance, -1)); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_WithKeyComparer() { var scheduler = new TestScheduler(); @@ -2000,7 +2003,7 @@ public void GroupByUntil_Capacity_WithKeyComparer() Assert.Equal(12, keyInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_Complete() { var scheduler = new TestScheduler(); @@ -2067,7 +2070,7 @@ public void GroupByUntil_Capacity_Outer_Complete() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_Error() { var scheduler = new TestScheduler(); @@ -2135,7 +2138,7 @@ public void GroupByUntil_Capacity_Outer_Error() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_Dispose() { var scheduler = new TestScheduler(); @@ -2200,7 +2203,7 @@ public void GroupByUntil_Capacity_Outer_Dispose() Assert.Equal(5, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_KeyThrow() { var scheduler = new TestScheduler(); @@ -2273,7 +2276,7 @@ public void GroupByUntil_Capacity_Outer_KeyThrow() Assert.Equal(9, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_EleThrow() { var scheduler = new TestScheduler(); @@ -2346,7 +2349,7 @@ public void GroupByUntil_Capacity_Outer_EleThrow() Assert.Equal(10, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_ComparerEqualsThrow() { var scheduler = new TestScheduler(); @@ -2410,7 +2413,7 @@ public void GroupByUntil_Capacity_Outer_ComparerEqualsThrow() Assert.Equal(3, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_ComparerGetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -2476,7 +2479,7 @@ public void GroupByUntil_Capacity_Outer_ComparerGetHashCodeThrow() Assert.Equal(7, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Complete() { var scheduler = new TestScheduler(); @@ -2562,7 +2565,7 @@ public void GroupByUntil_Capacity_Inner_Complete() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Complete_All() { var scheduler = new TestScheduler(); @@ -2656,7 +2659,7 @@ public void GroupByUntil_Capacity_Inner_Complete_All() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Error() { var scheduler = new TestScheduler(); @@ -2744,7 +2747,7 @@ public void GroupByUntil_Capacity_Inner_Error() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Dispose() { var scheduler = new TestScheduler(); @@ -2826,7 +2829,7 @@ public void GroupByUntil_Capacity_Inner_Dispose() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_KeyThrow() { var scheduler = new TestScheduler(); @@ -2917,7 +2920,7 @@ public void GroupByUntil_Capacity_Inner_KeyThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_EleThrow() { var scheduler = new TestScheduler(); @@ -3012,7 +3015,7 @@ public void GroupByUntil_Capacity_Inner_EleThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Comparer_EqualsThrow() { var scheduler = new TestScheduler(); @@ -3097,7 +3100,7 @@ public void GroupByUntil_Capacity_Inner_Comparer_EqualsThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Comparer_GetHashCodeThrow() { var scheduler = new TestScheduler(); @@ -3182,7 +3185,7 @@ public void GroupByUntil_Capacity_Inner_Comparer_GetHashCodeThrow() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Outer_Independence() { var scheduler = new TestScheduler(); @@ -3267,7 +3270,7 @@ public void GroupByUntil_Capacity_Outer_Independence() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Independence() { var scheduler = new TestScheduler(); @@ -3365,7 +3368,7 @@ public void GroupByUntil_Capacity_Inner_Independence() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Multiple_Independence() { var scheduler = new TestScheduler(); @@ -3459,7 +3462,7 @@ public void GroupByUntil_Capacity_Inner_Multiple_Independence() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Escape_Complete() { var scheduler = new TestScheduler(); @@ -3505,7 +3508,7 @@ public void GroupByUntil_Capacity_Inner_Escape_Complete() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Escape_Error() { var scheduler = new TestScheduler(); @@ -3553,7 +3556,7 @@ public void GroupByUntil_Capacity_Inner_Escape_Error() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Inner_Escape_Dispose() { var scheduler = new TestScheduler(); @@ -3599,7 +3602,7 @@ public void GroupByUntil_Capacity_Inner_Escape_Dispose() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_Default() { var scheduler = new TestScheduler(); @@ -3663,7 +3666,7 @@ public void GroupByUntil_Capacity_Default() Assert.Equal(12, eleInvoked); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_DurationSelector_Throws() { var scheduler = new TestScheduler(); @@ -3687,7 +3690,7 @@ public void GroupByUntil_Capacity_DurationSelector_Throws() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_NullKeys_Simple_Never() { var scheduler = new TestScheduler(); @@ -3715,7 +3718,7 @@ public void GroupByUntil_Capacity_NullKeys_Simple_Never() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_NullKeys_Simple_Expire1() { var scheduler = new TestScheduler(); @@ -3746,7 +3749,7 @@ public void GroupByUntil_Capacity_NullKeys_Simple_Expire1() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_NullKeys_Simple_Expire2() { var scheduler = new TestScheduler(); @@ -3777,7 +3780,7 @@ public void GroupByUntil_Capacity_NullKeys_Simple_Expire2() ); } - [Fact] + [TestMethod] public void GroupByUntil_Capacity_NullKeys_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupJoinTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupJoinTest.cs index 6048a5562c..53cfa4fa66 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupJoinTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/GroupJoinTest.cs @@ -9,14 +9,17 @@ 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 GroupJoinTest : ReactiveTest { - [Fact] + [TestMethod] public void GroupJoinOp_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.GroupJoin(null, DummyObservable.Instance, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc, int>.Instance)); @@ -27,7 +30,7 @@ public void GroupJoinOp_ArgumentChecking() ReactiveAssert.Throws(() => Observable.GroupJoin(DummyObservable.Instance, DummyObservable.Instance, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc, int>.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_I() { var scheduler = new TestScheduler(); @@ -116,7 +119,7 @@ public void GroupJoinOp_Normal_I() #endif } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_II() { var scheduler = new TestScheduler(); @@ -197,7 +200,7 @@ public void GroupJoinOp_Normal_II() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_III() { var scheduler = new TestScheduler(); @@ -286,7 +289,7 @@ public void GroupJoinOp_Normal_III() #endif } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_IV() { var scheduler = new TestScheduler(); @@ -367,7 +370,7 @@ public void GroupJoinOp_Normal_IV() #endif } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_V() { var scheduler = new TestScheduler(); @@ -448,7 +451,7 @@ public void GroupJoinOp_Normal_V() #endif } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_VI() { var scheduler = new TestScheduler(); @@ -536,7 +539,7 @@ public void GroupJoinOp_Normal_VI() #endif } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_VII() { var scheduler = new TestScheduler(); @@ -582,7 +585,7 @@ public void GroupJoinOp_Normal_VII() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_VIII() { var scheduler = new TestScheduler(); @@ -625,7 +628,7 @@ public void GroupJoinOp_Normal_VIII() #endif } - [Fact] + [TestMethod] public void GroupJoinOp_Normal_IX() { var scheduler = new TestScheduler(); @@ -694,7 +697,7 @@ public void GroupJoinOp_Normal_IX() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_I() { var scheduler = new TestScheduler(); @@ -752,7 +755,7 @@ public void GroupJoinOp_Error_I() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_II() { var scheduler = new TestScheduler(); @@ -823,7 +826,7 @@ public void GroupJoinOp_Error_II() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_III() { var scheduler = new TestScheduler(); @@ -899,7 +902,7 @@ public void GroupJoinOp_Error_III() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_IV() { var scheduler = new TestScheduler(); @@ -972,7 +975,7 @@ public void GroupJoinOp_Error_IV() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_V() { var scheduler = new TestScheduler(); @@ -1028,7 +1031,7 @@ public void GroupJoinOp_Error_V() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_VI() { var scheduler = new TestScheduler(); @@ -1084,7 +1087,7 @@ public void GroupJoinOp_Error_VI() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_VII() { var scheduler = new TestScheduler(); @@ -1144,7 +1147,7 @@ public void GroupJoinOp_Error_VII() ); } - [Fact] + [TestMethod] public void GroupJoinOp_Error_VIII() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IfTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IfTest.cs index d7da113ac0..76982dff26 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IfTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IfTest.cs @@ -7,14 +7,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class IfTest : ReactiveTest { - [Fact] + [TestMethod] public void If_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.If(null, DummyObservable.Instance, DummyObservable.Instance)); @@ -25,7 +26,7 @@ public void If_ArgumentChecking() ReactiveAssert.Throws(() => Observable.If(DummyFunc.Instance, DummyObservable.Instance, default(IScheduler))); } - [Fact] + [TestMethod] public void If_True() { var scheduler = new TestScheduler(); @@ -58,7 +59,7 @@ public void If_True() ); } - [Fact] + [TestMethod] public void If_False() { var scheduler = new TestScheduler(); @@ -91,7 +92,7 @@ public void If_False() ); } - [Fact] + [TestMethod] public void If_Throw() { var scheduler = new TestScheduler(); @@ -123,7 +124,7 @@ public void If_Throw() ); } - [Fact] + [TestMethod] public void If_Dispose() { var scheduler = new TestScheduler(); @@ -154,14 +155,14 @@ public void If_Dispose() ); } - [Fact] + [TestMethod] public void If_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.If(null, DummyObservable.Instance)); ReactiveAssert.Throws(() => Observable.If(DummyFunc.Instance, null)); } - [Fact] + [TestMethod] public void If_Default_Completed() { var scheduler = new TestScheduler(); @@ -190,7 +191,7 @@ public void If_Default_Completed() ); } - [Fact] + [TestMethod] public void If_Default_Error() { var scheduler = new TestScheduler(); @@ -221,7 +222,7 @@ public void If_Default_Error() ); } - [Fact] + [TestMethod] public void If_Default_Never() { var scheduler = new TestScheduler(); @@ -248,7 +249,7 @@ public void If_Default_Never() ); } - [Fact] + [TestMethod] public void If_Default_Other() { var scheduler = new TestScheduler(); @@ -274,7 +275,7 @@ public void If_Default_Other() ); } - [Fact] + [TestMethod] public void If_Default_Scheduler() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IgnoreElementsTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IgnoreElementsTest.cs index e6a3f98646..5faa6a5a61 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IgnoreElementsTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IgnoreElementsTest.cs @@ -5,20 +5,21 @@ using System; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class IgnoreElementsTest : ReactiveTest { - [Fact] + [TestMethod] public void IgnoreElements_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.IgnoreElements(null)); } - [Fact] + [TestMethod] public void IgnoreElements_IgnoreElements() { var scheduler = new TestScheduler(); @@ -44,7 +45,7 @@ public void IgnoreElements_IgnoreElements() ); } - [Fact] + [TestMethod] public void IgnoreElements_Basic() { var scheduler = new TestScheduler(); @@ -73,7 +74,7 @@ public void IgnoreElements_Basic() ); } - [Fact] + [TestMethod] public void IgnoreElements_Completed() { var scheduler = new TestScheduler(); @@ -104,7 +105,7 @@ public void IgnoreElements_Completed() ); } - [Fact] + [TestMethod] public void IgnoreElements_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IntervalTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IntervalTest.cs index 48fa7cfabe..e419223b89 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IntervalTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IntervalTest.cs @@ -8,14 +8,17 @@ 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 IntervalTest : ReactiveTest { - [Fact] + [TestMethod] public void Interval_TimeSpan_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Interval(TimeSpan.Zero, null)); @@ -24,7 +27,7 @@ public void Interval_TimeSpan_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Interval(TimeSpan.FromSeconds(-1), DummyScheduler.Instance)); } - [Fact] + [TestMethod] public void Interval_TimeSpan_Basic() { var scheduler = new TestScheduler(); @@ -44,7 +47,7 @@ public void Interval_TimeSpan_Basic() ); } - [Fact] + [TestMethod] public void Interval_TimeSpan_Zero() { var scheduler = new TestScheduler(); @@ -67,7 +70,7 @@ public void Interval_TimeSpan_Zero() ); } - [Fact] + [TestMethod] public void Interval_TimeSpan_Zero_DefaultScheduler() { var scheduler = new TestScheduler(); @@ -82,7 +85,7 @@ public void Interval_TimeSpan_Zero_DefaultScheduler() Assert.Equal(10, observer.Messages.Count); } - [Fact] + [TestMethod] public void Interval_TimeSpan_Disposed() { var scheduler = new TestScheduler(); @@ -95,7 +98,7 @@ public void Interval_TimeSpan_Disposed() ); } - [Fact] + [TestMethod] public void Interval_TimeSpan_ObserverThrows() { var scheduler = new TestScheduler(); @@ -107,7 +110,7 @@ public void Interval_TimeSpan_ObserverThrows() ReactiveAssert.Throws(() => scheduler.Start()); } - [Fact] + [TestMethod] public void Interval_TimeSpan_DefaultScheduler() { Assert.True(Observable.Interval(TimeSpan.FromMilliseconds(1)).ToEnumerable().Take(3).SequenceEqual(new[] { 0L, 1L, 2L })); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IsEmptyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IsEmptyTest.cs index 6f051aece8..1692d6f173 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IsEmptyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/IsEmptyTest.cs @@ -5,20 +5,21 @@ using System; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class IsEmptyTest : ReactiveTest { - [Fact] + [TestMethod] public void IsEmpty_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.IsEmpty(default(IObservable))); } - [Fact] + [TestMethod] public void IsEmpty_Empty() { var scheduler = new TestScheduler(); @@ -42,7 +43,7 @@ public void IsEmpty_Empty() ); } - [Fact] + [TestMethod] public void IsEmpty_Return() { var scheduler = new TestScheduler(); @@ -67,7 +68,7 @@ public void IsEmpty_Return() ); } - [Fact] + [TestMethod] public void IsEmpty_Throw() { var ex = new Exception(); @@ -92,7 +93,7 @@ public void IsEmpty_Throw() ); } - [Fact] + [TestMethod] public void IsEmpty_Never() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/JoinTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/JoinTest.cs index 2cf71d56eb..ef96037b31 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/JoinTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/JoinTest.cs @@ -9,14 +9,17 @@ 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 JoinTest : ReactiveTest { - [Fact] + [TestMethod] public void JoinOp_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Join(null, DummyObservable.Instance, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc.Instance)); @@ -27,7 +30,7 @@ public void JoinOp_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Join(DummyObservable.Instance, DummyObservable.Instance, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void JoinOp_Normal_I() { var scheduler = new TestScheduler(); @@ -110,7 +113,7 @@ public void JoinOp_Normal_I() AssertDurations(ys, ysd, 900); } - [Fact] + [TestMethod] public void JoinOp_Normal_II() { var scheduler = new TestScheduler(); @@ -191,7 +194,7 @@ public void JoinOp_Normal_II() AssertDurations(ys, ysd, 910); } - [Fact] + [TestMethod] public void JoinOp_Normal_III() { var scheduler = new TestScheduler(); @@ -274,7 +277,7 @@ public void JoinOp_Normal_III() AssertDurations(ys, ysd, 900); } - [Fact] + [TestMethod] public void JoinOp_Normal_IV() { var scheduler = new TestScheduler(); @@ -349,7 +352,7 @@ public void JoinOp_Normal_IV() AssertDurations(ys, ysd, 980); } - [Fact] + [TestMethod] public void JoinOp_Normal_V() { var scheduler = new TestScheduler(); @@ -430,7 +433,7 @@ public void JoinOp_Normal_V() AssertDurations(ys, ysd, 922); } - [Fact] + [TestMethod] public void JoinOp_Normal_VI() { var scheduler = new TestScheduler(); @@ -512,7 +515,7 @@ public void JoinOp_Normal_VI() AssertDurations(ys, ysd, 900); } - [Fact] + [TestMethod] public void JoinOp_Normal_VII() { var scheduler = new TestScheduler(); @@ -581,7 +584,7 @@ public void JoinOp_Normal_VII() AssertDurations(ys, ysd, 713); } - [Fact] + [TestMethod] public void JoinOp_Error_I() { var scheduler = new TestScheduler(); @@ -639,7 +642,7 @@ public void JoinOp_Error_I() AssertDurations(ys, ysd, 310); } - [Fact] + [TestMethod] public void JoinOp_Error_II() { var scheduler = new TestScheduler(); @@ -710,7 +713,7 @@ public void JoinOp_Error_II() AssertDurations(ys, ysd, 722); } - [Fact] + [TestMethod] public void JoinOp_Error_III() { var scheduler = new TestScheduler(); @@ -786,7 +789,7 @@ public void JoinOp_Error_III() AssertDurations(ys, ysd, 725); } - [Fact] + [TestMethod] public void JoinOp_Error_IV() { var scheduler = new TestScheduler(); @@ -859,7 +862,7 @@ public void JoinOp_Error_IV() AssertDurations(ys, ysd, 721); } - [Fact] + [TestMethod] public void JoinOp_Error_V() { var scheduler = new TestScheduler(); @@ -915,7 +918,7 @@ public void JoinOp_Error_V() AssertDurations(ys, ysd, 210); } - [Fact] + [TestMethod] public void JoinOp_Error_VI() { var scheduler = new TestScheduler(); @@ -971,7 +974,7 @@ public void JoinOp_Error_VI() AssertDurations(xs, xsd, 215); } - [Fact] + [TestMethod] public void JoinOp_Error_VII() { var scheduler = new TestScheduler(); @@ -1029,7 +1032,7 @@ public void JoinOp_Error_VII() AssertDurations(ys, ysd, 215); } - [Fact] + [TestMethod] public void JoinOp_Error_VIII() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastAsyncTest.cs index 9a95aeb6b1..6382ab3cff 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastAsyncTest.cs @@ -6,14 +6,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class LastAsyncTest : ReactiveTest { - [Fact] + [TestMethod] public void LastAsync_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.LastAsync(default(IObservable))); @@ -21,7 +22,7 @@ public void LastAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.LastAsync(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void LastAsync_Empty() { var scheduler = new TestScheduler(); @@ -44,7 +45,7 @@ public void LastAsync_Empty() ); } - [Fact] + [TestMethod] public void LastAsync_One() { var scheduler = new TestScheduler(); @@ -69,7 +70,7 @@ public void LastAsync_One() ); } - [Fact] + [TestMethod] public void LastAsync_Many() { var scheduler = new TestScheduler(); @@ -95,7 +96,7 @@ public void LastAsync_Many() ); } - [Fact] + [TestMethod] public void LastAsync_Error() { var scheduler = new TestScheduler(); @@ -120,7 +121,7 @@ public void LastAsync_Error() ); } - [Fact] + [TestMethod] public void LastAsync_Predicate() { var scheduler = new TestScheduler(); @@ -148,7 +149,7 @@ public void LastAsync_Predicate() ); } - [Fact] + [TestMethod] public void LastAsync_Predicate_None() { var scheduler = new TestScheduler(); @@ -175,7 +176,7 @@ public void LastAsync_Predicate_None() ); } - [Fact] + [TestMethod] public void LastAsync_Predicate_Throw() { var scheduler = new TestScheduler(); @@ -200,7 +201,7 @@ public void LastAsync_Predicate_Throw() ); } - [Fact] + [TestMethod] public void LastAsync_PredicateThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultAsyncTest.cs index 4aa31310c9..5105bdd34a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultAsyncTest.cs @@ -6,14 +6,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class LastOrDefaultAsyncTest : ReactiveTest { - [Fact] + [TestMethod] public void LastOrDefaultAsync_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.LastOrDefaultAsync(default(IObservable))); @@ -21,7 +22,7 @@ public void LastOrDefaultAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.LastOrDefaultAsync(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_Empty() { var scheduler = new TestScheduler(); @@ -45,7 +46,7 @@ public void LastOrDefaultAsync_Empty() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_One() { var scheduler = new TestScheduler(); @@ -70,7 +71,7 @@ public void LastOrDefaultAsync_One() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_Many() { var scheduler = new TestScheduler(); @@ -96,7 +97,7 @@ public void LastOrDefaultAsync_Many() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_Error() { var scheduler = new TestScheduler(); @@ -121,7 +122,7 @@ public void LastOrDefaultAsync_Error() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_Predicate() { var scheduler = new TestScheduler(); @@ -149,7 +150,7 @@ public void LastOrDefaultAsync_Predicate() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_Predicate_None() { var scheduler = new TestScheduler(); @@ -177,7 +178,7 @@ public void LastOrDefaultAsync_Predicate_None() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_Predicate_Throw() { var scheduler = new TestScheduler(); @@ -202,7 +203,7 @@ public void LastOrDefaultAsync_Predicate_Throw() ); } - [Fact] + [TestMethod] public void LastOrDefaultAsync_PredicateThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultTest.cs index 1afd4225e9..8f8d78c3d0 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastOrDefaultTest.cs @@ -7,14 +7,17 @@ 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 LastOrDefaultTest : ReactiveTest { - [Fact] + [TestMethod] public void LastOrDefault_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.LastOrDefault(default(IObservable))); @@ -22,26 +25,26 @@ public void LastOrDefault_ArgumentChecking() ReactiveAssert.Throws(() => Observable.LastOrDefault(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void LastOrDefault_Empty() { Assert.Equal(default, Observable.Empty().LastOrDefault()); } - [Fact] + [TestMethod] public void LastOrDefaultPredicate_Empty() { Assert.Equal(default, Observable.Empty().LastOrDefault(_ => true)); } - [Fact] + [TestMethod] public void LastOrDefault_Return() { var value = 42; Assert.Equal(value, Observable.Return(value).LastOrDefault()); } - [Fact] + [TestMethod] public void LastOrDefault_Throw() { var ex = new Exception(); @@ -51,14 +54,14 @@ public void LastOrDefault_Throw() ReactiveAssert.Throws(ex, () => xs.LastOrDefault()); } - [Fact] + [TestMethod] public void LastOrDefault_Range() { var value = 42; Assert.Equal(value, Observable.Range(value - 9, 10).LastOrDefault()); } - [Fact] + [TestMethod] public void LastOrDefaultPredicate_Range() { var value = 42; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastTest.cs index af9f1be515..e7aaf07c17 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LastTest.cs @@ -7,14 +7,17 @@ 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 LastTest : ReactiveTest { - [Fact] + [TestMethod] public void Last_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Last(default(IObservable))); @@ -22,26 +25,26 @@ public void Last_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Last(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void Last_Empty() { ReactiveAssert.Throws(() => Observable.Empty().Last()); } - [Fact] + [TestMethod] public void LastPredicate_Empty() { ReactiveAssert.Throws(() => Observable.Empty().Last(_ => true)); } - [Fact] + [TestMethod] public void Last_Return() { var value = 42; Assert.Equal(value, Observable.Return(value).Last()); } - [Fact] + [TestMethod] public void Last_Throw() { var ex = new Exception(); @@ -51,14 +54,14 @@ public void Last_Throw() ReactiveAssert.Throws(ex, () => xs.Last()); } - [Fact] + [TestMethod] public void Last_Range() { var value = 42; Assert.Equal(value, Observable.Range(value - 9, 10).Last()); } - [Fact] + [TestMethod] public void LastPredicate_Range() { var value = 42; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LatestTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LatestTest.cs index 233b76e146..656de04734 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LatestTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LatestTest.cs @@ -10,20 +10,23 @@ 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 LatestTest : ReactiveTest { - [Fact] + [TestMethod] public void Latest_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Latest(default(IObservable))); } - [Fact] + [TestMethod] public void Latest1() { var disposed = false; @@ -68,7 +71,7 @@ public void Latest1() Assert.True(disposed); } - [Fact] + [TestMethod] public void Latest2() { var scheduler = new TestScheduler(); @@ -137,7 +140,7 @@ public void Latest2() o2.AssertEqual(6, 7); } - [Fact] + [TestMethod] public void Latest_Error() { SynchronizationContext.SetSynchronizationContext(null); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LetTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LetTest.cs index 8bd90bb401..15ade48962 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LetTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LetTest.cs @@ -5,15 +5,18 @@ 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 LetTest : ReactiveTest { #region Let - [Fact] + [TestMethod] public void Let_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -22,7 +25,7 @@ public void Let_ArgumentChecking() ReactiveAssert.Throws(() => ObservableEx.Let(someObservable, null)); } - [Fact] + [TestMethod] public void Let_CallsFunctionImmediately() { var called = false; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LongCountTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LongCountTest.cs index 2a2e736179..cc62e8111f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LongCountTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/LongCountTest.cs @@ -8,14 +8,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class LongCountTest : ReactiveTest { - [Fact] + [TestMethod] public void LongCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.LongCount(default(IObservable))); @@ -23,7 +24,7 @@ public void LongCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.LongCount(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void LongCount_Empty() { var scheduler = new TestScheduler(); @@ -47,7 +48,7 @@ public void LongCount_Empty() ); } - [Fact] + [TestMethod] public void LongCount_Return() { var scheduler = new TestScheduler(); @@ -72,7 +73,7 @@ public void LongCount_Return() ); } - [Fact] + [TestMethod] public void LongCount_Some() { var scheduler = new TestScheduler(); @@ -99,7 +100,7 @@ public void LongCount_Some() ); } - [Fact] + [TestMethod] public void LongCount_Throw() { var ex = new Exception(); @@ -124,7 +125,7 @@ public void LongCount_Throw() ); } - [Fact] + [TestMethod] public void LongCount_Never() { var scheduler = new TestScheduler(); @@ -146,7 +147,7 @@ public void LongCount_Never() } #if !NO_PERF && !NO_THREAD - [Fact] + [TestMethod] public void LongCount_InjectOverflow() { var xs = Observable.Return(42, ThreadPoolScheduler.Instance); @@ -157,7 +158,7 @@ public void LongCount_InjectOverflow() } #endif - [Fact] + [TestMethod] public void LongCount_Predicate_Empty_True() { var scheduler = new TestScheduler(); @@ -181,7 +182,7 @@ public void LongCount_Predicate_Empty_True() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Empty_False() { var scheduler = new TestScheduler(); @@ -205,7 +206,7 @@ public void LongCount_Predicate_Empty_False() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Return_True() { var scheduler = new TestScheduler(); @@ -230,7 +231,7 @@ public void LongCount_Predicate_Return_True() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Return_False() { var scheduler = new TestScheduler(); @@ -255,7 +256,7 @@ public void LongCount_Predicate_Return_False() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Some_All() { var scheduler = new TestScheduler(); @@ -282,7 +283,7 @@ public void LongCount_Predicate_Some_All() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Some_None() { var scheduler = new TestScheduler(); @@ -309,7 +310,7 @@ public void LongCount_Predicate_Some_None() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Some_Even() { var scheduler = new TestScheduler(); @@ -336,7 +337,7 @@ public void LongCount_Predicate_Some_Even() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Throw_True() { var ex = new Exception(); @@ -361,7 +362,7 @@ public void LongCount_Predicate_Throw_True() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Throw_False() { var ex = new Exception(); @@ -386,7 +387,7 @@ public void LongCount_Predicate_Throw_False() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_Never() { var scheduler = new TestScheduler(); @@ -407,7 +408,7 @@ public void LongCount_Predicate_Never() ); } - [Fact] + [TestMethod] public void LongCount_Predicate_PredicateThrows() { var scheduler = new TestScheduler(); @@ -443,7 +444,7 @@ public void LongCount_Predicate_PredicateThrows() } #if !NO_PERF && !NO_THREAD && !CRIPPLED_REFLECTION - [Fact] + [TestMethod] public void LongCount_Predicate_InjectOverflow() { var xs = Observable.Return(42, ThreadPoolScheduler.Instance); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ManySelectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ManySelectTest.cs index 4eb322d222..4505b0310a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ManySelectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ManySelectTest.cs @@ -7,15 +7,18 @@ 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 { #pragma warning disable IDE0039 // Use local function + [TestClass] public class ManySelectTest : ReactiveTest { - [Fact] + [TestMethod] public void ManySelect_ArgumentChecking() { ReactiveAssert.Throws(() => ObservableEx.ManySelect(null, DummyFunc, int>.Instance, DummyScheduler.Instance)); @@ -25,7 +28,7 @@ public void ManySelect_ArgumentChecking() ReactiveAssert.Throws(() => ObservableEx.ManySelect(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void ManySelect_Law_1() { var xs = Observable.Range(1, 0); @@ -36,7 +39,7 @@ public void ManySelect_Law_1() Assert.True(left.SequenceEqual(right).First()); } - [Fact] + [TestMethod] public void ManySelect_Law_2() { var xs = Observable.Range(1, 10); @@ -48,7 +51,7 @@ public void ManySelect_Law_2() Assert.Equal(left, right); } - [Fact] + [TestMethod] public void ManySelect_Law_3() { var xs = Observable.Range(1, 10); @@ -61,7 +64,7 @@ public void ManySelect_Law_3() Assert.True(left.SequenceEqual(right).First()); } - [Fact] + [TestMethod] public void ManySelect_Basic() { var scheduler = new TestScheduler(); @@ -90,7 +93,7 @@ public void ManySelect_Basic() ); } - [Fact] + [TestMethod] public void ManySelect_Error() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaterializeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaterializeTest.cs index 6844fc93b8..cd504de0ce 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaterializeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaterializeTest.cs @@ -6,20 +6,21 @@ using System.Reactive; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class MaterializeTest : ReactiveTest { - [Fact] + [TestMethod] public void Materialize_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Materialize(null)); } - [Fact] + [TestMethod] public void Materialize_Never() { var scheduler = new TestScheduler(); @@ -31,7 +32,7 @@ public void Materialize_Never() ); } - [Fact] + [TestMethod] public void Materialize_Empty() { var scheduler = new TestScheduler(); @@ -55,7 +56,7 @@ public void Materialize_Empty() ); } - [Fact] + [TestMethod] public void Materialize_Return() { var scheduler = new TestScheduler(); @@ -81,7 +82,7 @@ public void Materialize_Return() ); } - [Fact] + [TestMethod] public void Materialize_Throw() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxByTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxByTest.cs index 659917570c..b74bd5e0ad 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxByTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxByTest.cs @@ -8,15 +8,16 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class MaxByTest : ReactiveTest { #region + MaxBy + - [Fact] + [TestMethod] public void MaxBy_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.MaxBy(default(IObservable), x => x)); @@ -26,7 +27,7 @@ public void MaxBy_ArgumentChecking() ReactiveAssert.Throws(() => Observable.MaxBy(DummyObservable.Instance, x => x, null)); } - [Fact] + [TestMethod] public void MaxBy_Empty() { var scheduler = new TestScheduler(); @@ -50,7 +51,7 @@ public void MaxBy_Empty() ); } - [Fact] + [TestMethod] public void MaxBy_Return() { var scheduler = new TestScheduler(); @@ -77,7 +78,7 @@ public void MaxBy_Return() ); } - [Fact] + [TestMethod] public void MaxBy_Some() { var scheduler = new TestScheduler(); @@ -106,7 +107,7 @@ public void MaxBy_Some() ); } - [Fact] + [TestMethod] public void MaxBy_Multiple() { var scheduler = new TestScheduler(); @@ -138,7 +139,7 @@ public void MaxBy_Multiple() Subscribe(200, 250) ); } - [Fact] + [TestMethod] public void MaxBy_Throw() { var ex = new Exception(); @@ -163,7 +164,7 @@ public void MaxBy_Throw() ); } - [Fact] + [TestMethod] public void MaxBy_Never() { var ex = new Exception(); @@ -186,7 +187,7 @@ public void MaxBy_Never() ); } - [Fact] + [TestMethod] public void MaxBy_Comparer_Empty() { var scheduler = new TestScheduler(); @@ -210,7 +211,7 @@ public void MaxBy_Comparer_Empty() ); } - [Fact] + [TestMethod] public void MaxBy_Comparer_Return() { var scheduler = new TestScheduler(); @@ -237,7 +238,7 @@ public void MaxBy_Comparer_Return() ); } - [Fact] + [TestMethod] public void MaxBy_Comparer_Some() { var scheduler = new TestScheduler(); @@ -266,7 +267,7 @@ public void MaxBy_Comparer_Some() ); } - [Fact] + [TestMethod] public void MaxBy_Comparer_Throw() { var ex = new Exception(); @@ -291,7 +292,7 @@ public void MaxBy_Comparer_Throw() ); } - [Fact] + [TestMethod] public void MaxBy_Comparer_Never() { var ex = new Exception(); @@ -314,7 +315,7 @@ public void MaxBy_Comparer_Never() ); } - [Fact] + [TestMethod] public void MaxBy_SelectorThrows() { var ex = new Exception(); @@ -342,7 +343,7 @@ public void MaxBy_SelectorThrows() ); } - [Fact] + [TestMethod] public void MaxBy_ComparerThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxTest.cs index cfa0300075..280fbcad5a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MaxTest.cs @@ -7,13 +7,14 @@ using System.Linq; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class MaxTest : ReactiveTest { - [Fact] + [TestMethod] public void Max_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Max(default(IObservable))); @@ -62,7 +63,7 @@ public void Max_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Max(Observable.Empty(), _ => "", default)); } - [Fact] + [TestMethod] public void Max_Int32_Empty() { var scheduler = new TestScheduler(); @@ -85,7 +86,7 @@ public void Max_Int32_Empty() ); } - [Fact] + [TestMethod] public void Max_Int32_Return() { var scheduler = new TestScheduler(); @@ -110,7 +111,7 @@ public void Max_Int32_Return() ); } - [Fact] + [TestMethod] public void Max_Int32_Some() { var scheduler = new TestScheduler(); @@ -137,7 +138,7 @@ public void Max_Int32_Some() ); } - [Fact] + [TestMethod] public void Max_Int32_Throw() { var ex = new Exception(); @@ -162,7 +163,7 @@ public void Max_Int32_Throw() ); } - [Fact] + [TestMethod] public void Max_Int32_Never() { var ex = new Exception(); @@ -185,7 +186,7 @@ public void Max_Int32_Never() ); } - [Fact] + [TestMethod] public void Max_Int64_Empty() { var scheduler = new TestScheduler(); @@ -208,7 +209,7 @@ public void Max_Int64_Empty() ); } - [Fact] + [TestMethod] public void Max_Int64_Return() { var scheduler = new TestScheduler(); @@ -233,7 +234,7 @@ public void Max_Int64_Return() ); } - [Fact] + [TestMethod] public void Max_Int64_Some() { var scheduler = new TestScheduler(); @@ -260,7 +261,7 @@ public void Max_Int64_Some() ); } - [Fact] + [TestMethod] public void Max_Int64_Throw() { var ex = new Exception(); @@ -285,7 +286,7 @@ public void Max_Int64_Throw() ); } - [Fact] + [TestMethod] public void Max_Int64_Never() { var ex = new Exception(); @@ -308,7 +309,7 @@ public void Max_Int64_Never() ); } - [Fact] + [TestMethod] public void Max_Float_Empty() { var scheduler = new TestScheduler(); @@ -331,7 +332,7 @@ public void Max_Float_Empty() ); } - [Fact] + [TestMethod] public void Max_Float_Return() { var scheduler = new TestScheduler(); @@ -356,7 +357,7 @@ public void Max_Float_Return() ); } - [Fact] + [TestMethod] public void Max_Float_Some() { var scheduler = new TestScheduler(); @@ -383,7 +384,7 @@ public void Max_Float_Some() ); } - [Fact] + [TestMethod] public void Max_Float_Throw() { var ex = new Exception(); @@ -408,7 +409,7 @@ public void Max_Float_Throw() ); } - [Fact] + [TestMethod] public void Max_Float_Never() { var ex = new Exception(); @@ -431,7 +432,7 @@ public void Max_Float_Never() ); } - [Fact] + [TestMethod] public void Max_Double_Empty() { var scheduler = new TestScheduler(); @@ -454,7 +455,7 @@ public void Max_Double_Empty() ); } - [Fact] + [TestMethod] public void Max_Double_Return() { var scheduler = new TestScheduler(); @@ -479,7 +480,7 @@ public void Max_Double_Return() ); } - [Fact] + [TestMethod] public void Max_Double_Some() { var scheduler = new TestScheduler(); @@ -506,7 +507,7 @@ public void Max_Double_Some() ); } - [Fact] + [TestMethod] public void Max_Double_Throw() { var ex = new Exception(); @@ -531,7 +532,7 @@ public void Max_Double_Throw() ); } - [Fact] + [TestMethod] public void Max_Double_Never() { var ex = new Exception(); @@ -554,7 +555,7 @@ public void Max_Double_Never() ); } - [Fact] + [TestMethod] public void Max_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -577,7 +578,7 @@ public void Max_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Max_Decimal_Return() { var scheduler = new TestScheduler(); @@ -602,7 +603,7 @@ public void Max_Decimal_Return() ); } - [Fact] + [TestMethod] public void Max_Decimal_Some() { var scheduler = new TestScheduler(); @@ -629,7 +630,7 @@ public void Max_Decimal_Some() ); } - [Fact] + [TestMethod] public void Max_Decimal_Throw() { var ex = new Exception(); @@ -654,7 +655,7 @@ public void Max_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Max_Decimal_Never() { var ex = new Exception(); @@ -677,7 +678,7 @@ public void Max_Decimal_Never() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int32_Empty() { var scheduler = new TestScheduler(); @@ -701,7 +702,7 @@ public void Max_Nullable_Int32_Empty() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int32_Return() { var scheduler = new TestScheduler(); @@ -726,7 +727,7 @@ public void Max_Nullable_Int32_Return() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int32_Some1() { var scheduler = new TestScheduler(); @@ -753,7 +754,7 @@ public void Max_Nullable_Int32_Some1() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int32_Some2() { var scheduler = new TestScheduler(); @@ -780,7 +781,7 @@ public void Max_Nullable_Int32_Some2() ); } - [Fact] + [TestMethod] public void Max_Nullable_GeneralNullableMaxTest_LhsNull() { var scheduler = new TestScheduler(); @@ -806,7 +807,7 @@ public void Max_Nullable_GeneralNullableMaxTest_LhsNull() ); } - [Fact] + [TestMethod] public void Max_Nullable_GeneralNullableMaxTest_RhsNull() { var scheduler = new TestScheduler(); @@ -832,7 +833,7 @@ public void Max_Nullable_GeneralNullableMaxTest_RhsNull() ); } - [Fact] + [TestMethod] public void Max_Nullable_GeneralNullableMaxTest_Less() { var scheduler = new TestScheduler(); @@ -858,7 +859,7 @@ public void Max_Nullable_GeneralNullableMaxTest_Less() ); } - [Fact] + [TestMethod] public void Max_Nullable_GeneralNullableMaxTest_Greater() { var scheduler = new TestScheduler(); @@ -884,7 +885,7 @@ public void Max_Nullable_GeneralNullableMaxTest_Greater() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int32_Throw() { var ex = new Exception(); @@ -909,7 +910,7 @@ public void Max_Nullable_Int32_Throw() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int32_Never() { var ex = new Exception(); @@ -932,7 +933,7 @@ public void Max_Nullable_Int32_Never() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int64_Empty() { var scheduler = new TestScheduler(); @@ -956,7 +957,7 @@ public void Max_Nullable_Int64_Empty() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int64_Return() { var scheduler = new TestScheduler(); @@ -981,7 +982,7 @@ public void Max_Nullable_Int64_Return() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int64_Some1() { var scheduler = new TestScheduler(); @@ -1008,7 +1009,7 @@ public void Max_Nullable_Int64_Some1() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int64_Some2() { var scheduler = new TestScheduler(); @@ -1035,7 +1036,7 @@ public void Max_Nullable_Int64_Some2() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int64_Throw() { var ex = new Exception(); @@ -1060,7 +1061,7 @@ public void Max_Nullable_Int64_Throw() ); } - [Fact] + [TestMethod] public void Max_Nullable_Int64_Never() { var ex = new Exception(); @@ -1083,7 +1084,7 @@ public void Max_Nullable_Int64_Never() ); } - [Fact] + [TestMethod] public void Max_Nullable_Float_Empty() { var scheduler = new TestScheduler(); @@ -1107,7 +1108,7 @@ public void Max_Nullable_Float_Empty() ); } - [Fact] + [TestMethod] public void Max_Nullable_Float_Return() { var scheduler = new TestScheduler(); @@ -1132,7 +1133,7 @@ public void Max_Nullable_Float_Return() ); } - [Fact] + [TestMethod] public void Max_Nullable_Float_Some1() { var scheduler = new TestScheduler(); @@ -1159,7 +1160,7 @@ public void Max_Nullable_Float_Some1() ); } - [Fact] + [TestMethod] public void Max_Nullable_Float_Some2() { var scheduler = new TestScheduler(); @@ -1186,7 +1187,7 @@ public void Max_Nullable_Float_Some2() ); } - [Fact] + [TestMethod] public void Max_Nullable_Float_Throw() { var ex = new Exception(); @@ -1211,7 +1212,7 @@ public void Max_Nullable_Float_Throw() ); } - [Fact] + [TestMethod] public void Max_Nullable_Float_Never() { var ex = new Exception(); @@ -1234,7 +1235,7 @@ public void Max_Nullable_Float_Never() ); } - [Fact] + [TestMethod] public void Max_Nullable_Double_Empty() { var scheduler = new TestScheduler(); @@ -1258,7 +1259,7 @@ public void Max_Nullable_Double_Empty() ); } - [Fact] + [TestMethod] public void Max_Nullable_Double_Return() { var scheduler = new TestScheduler(); @@ -1283,7 +1284,7 @@ public void Max_Nullable_Double_Return() ); } - [Fact] + [TestMethod] public void Max_Nullable_Double_Some1() { var scheduler = new TestScheduler(); @@ -1310,7 +1311,7 @@ public void Max_Nullable_Double_Some1() ); } - [Fact] + [TestMethod] public void Max_Nullable_Double_Some2() { var scheduler = new TestScheduler(); @@ -1337,7 +1338,7 @@ public void Max_Nullable_Double_Some2() ); } - [Fact] + [TestMethod] public void Max_Nullable_Double_Throw() { var ex = new Exception(); @@ -1362,7 +1363,7 @@ public void Max_Nullable_Double_Throw() ); } - [Fact] + [TestMethod] public void Max_Nullable_Double_Never() { var ex = new Exception(); @@ -1385,7 +1386,7 @@ public void Max_Nullable_Double_Never() ); } - [Fact] + [TestMethod] public void Max_Nullable_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -1409,7 +1410,7 @@ public void Max_Nullable_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Max_Nullable_Decimal_Return() { var scheduler = new TestScheduler(); @@ -1434,7 +1435,7 @@ public void Max_Nullable_Decimal_Return() ); } - [Fact] + [TestMethod] public void Max_Nullable_Decimal_Some1() { var scheduler = new TestScheduler(); @@ -1461,7 +1462,7 @@ public void Max_Nullable_Decimal_Some1() ); } - [Fact] + [TestMethod] public void Max_Nullable_Decimal_Some2() { var scheduler = new TestScheduler(); @@ -1488,7 +1489,7 @@ public void Max_Nullable_Decimal_Some2() ); } - [Fact] + [TestMethod] public void Max_Nullable_Decimal_Throw() { var ex = new Exception(); @@ -1513,7 +1514,7 @@ public void Max_Nullable_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Max_Nullable_Decimal_Never() { var ex = new Exception(); @@ -1536,7 +1537,7 @@ public void Max_Nullable_Decimal_Never() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Empty() { var scheduler = new TestScheduler(); @@ -1567,7 +1568,7 @@ public void MaxOfT_Reference_Empty() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Empty() { var scheduler = new TestScheduler(); @@ -1590,7 +1591,7 @@ public void MaxOfT_Value_Empty() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Return() { var scheduler = new TestScheduler(); @@ -1615,7 +1616,7 @@ public void MaxOfT_Reference_Return() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Return() { var scheduler = new TestScheduler(); @@ -1640,7 +1641,7 @@ public void MaxOfT_Value_Return() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Some() { var scheduler = new TestScheduler(); @@ -1667,7 +1668,7 @@ public void MaxOfT_Reference_Some() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Some() { var scheduler = new TestScheduler(); @@ -1694,7 +1695,7 @@ public void MaxOfT_Value_Some() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Throw() { var ex = new Exception(); @@ -1719,7 +1720,7 @@ public void MaxOfT_Reference_Throw() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Throw() { var ex = new Exception(); @@ -1744,7 +1745,7 @@ public void MaxOfT_Value_Throw() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Never() { var ex = new Exception(); @@ -1767,7 +1768,7 @@ public void MaxOfT_Reference_Never() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Never() { var ex = new Exception(); @@ -1790,7 +1791,7 @@ public void MaxOfT_Value_Never() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Comparer_Empty() { var scheduler = new TestScheduler(); @@ -1821,7 +1822,7 @@ public void MaxOfT_Reference_Comparer_Empty() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Comparer_Empty() { var scheduler = new TestScheduler(); @@ -1844,7 +1845,7 @@ public void MaxOfT_Value_Comparer_Empty() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Comparer_Return() { var scheduler = new TestScheduler(); @@ -1869,7 +1870,7 @@ public void MaxOfT_Reference_Comparer_Return() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Comparer_Return() { var scheduler = new TestScheduler(); @@ -1894,7 +1895,7 @@ public void MaxOfT_Value_Comparer_Return() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Comparer_Some() { var scheduler = new TestScheduler(); @@ -1921,7 +1922,7 @@ public void MaxOfT_Reference_Comparer_Some() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Comparer_Some() { var scheduler = new TestScheduler(); @@ -1948,7 +1949,7 @@ public void MaxOfT_Value_Comparer_Some() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Comparer_Throw() { var ex = new Exception(); @@ -1973,7 +1974,7 @@ public void MaxOfT_Reference_Comparer_Throw() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Comparer_Throw() { var ex = new Exception(); @@ -1998,7 +1999,7 @@ public void MaxOfT_Value_Comparer_Throw() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_Comparer_Never() { var ex = new Exception(); @@ -2021,7 +2022,7 @@ public void MaxOfT_Reference_Comparer_Never() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_Comparer_Never() { var ex = new Exception(); @@ -2044,7 +2045,7 @@ public void MaxOfT_Value_Comparer_Never() ); } - [Fact] + [TestMethod] public void MaxOfT_Reference_ComparerThrows() { var ex = new Exception(); @@ -2072,7 +2073,7 @@ public void MaxOfT_Reference_ComparerThrows() ); } - [Fact] + [TestMethod] public void MaxOfT_Value_ComparerThrows() { var ex = new Exception(); @@ -2100,7 +2101,7 @@ public void MaxOfT_Value_ComparerThrows() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Int32() { var scheduler = new TestScheduler(); @@ -2124,7 +2125,7 @@ public void Max_Selector_Regular_Int32() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Int64() { var scheduler = new TestScheduler(); @@ -2148,7 +2149,7 @@ public void Max_Selector_Regular_Int64() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Single() { var scheduler = new TestScheduler(); @@ -2172,7 +2173,7 @@ public void Max_Selector_Regular_Single() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Double() { var scheduler = new TestScheduler(); @@ -2196,7 +2197,7 @@ public void Max_Selector_Regular_Double() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Decimal() { var scheduler = new TestScheduler(); @@ -2220,7 +2221,7 @@ public void Max_Selector_Regular_Decimal() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Int32_Nullable() { var scheduler = new TestScheduler(); @@ -2244,7 +2245,7 @@ public void Max_Selector_Regular_Int32_Nullable() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Int64_Nullable() { var scheduler = new TestScheduler(); @@ -2268,7 +2269,7 @@ public void Max_Selector_Regular_Int64_Nullable() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Single_Nullable() { var scheduler = new TestScheduler(); @@ -2292,7 +2293,7 @@ public void Max_Selector_Regular_Single_Nullable() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Double_Nullable() { var scheduler = new TestScheduler(); @@ -2316,7 +2317,7 @@ public void Max_Selector_Regular_Double_Nullable() ); } - [Fact] + [TestMethod] public void Max_Selector_Regular_Decimal_Nullable() { var scheduler = new TestScheduler(); @@ -2340,7 +2341,7 @@ public void Max_Selector_Regular_Decimal_Nullable() ); } - [Fact] + [TestMethod] public void MaxOfT_Selector_Regular() { var scheduler = new TestScheduler(); @@ -2364,7 +2365,7 @@ public void MaxOfT_Selector_Regular() ); } - [Fact] + [TestMethod] public void MaxOfT_Selector_Regular_Comparer() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MergeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MergeTest.cs index a0ac998069..8386e17b94 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MergeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MergeTest.cs @@ -13,14 +13,17 @@ 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 MergeTest : ReactiveTest { - [Fact] + [TestMethod] public void Merge_ArgumentChecking() { var xs = DummyObservable.Instance; @@ -40,7 +43,7 @@ public void Merge_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Merge((IObservable>)null)); } - [Fact] + [TestMethod] public void Merge_DefaultScheduler() { var xs = Observable.Merge(Observable.Return(42), Observable.Return(43), Observable.Return(44)); @@ -48,7 +51,7 @@ public void Merge_DefaultScheduler() Assert.True(new[] { 42, 43, 44 }.SequenceEqual(res)); } - [Fact] + [TestMethod] public void Merge_Never2() { var scheduler = new TestScheduler(); @@ -77,7 +80,7 @@ public void Merge_Never2() ); } - [Fact] + [TestMethod] public void Merge_Never3() { var scheduler = new TestScheduler(); @@ -114,7 +117,7 @@ public void Merge_Never3() ); } - [Fact] + [TestMethod] public void Merge_Empty2() { var scheduler = new TestScheduler(); @@ -146,7 +149,7 @@ public void Merge_Empty2() ); } - [Fact] + [TestMethod] public void Merge_Empty3() { var scheduler = new TestScheduler(); @@ -187,7 +190,7 @@ public void Merge_Empty3() ); } - [Fact] + [TestMethod] public void Merge_EmptyDelayed2_RightLast() { var scheduler = new TestScheduler(); @@ -219,7 +222,7 @@ public void Merge_EmptyDelayed2_RightLast() ); } - [Fact] + [TestMethod] public void Merge_EmptyDelayed2_LeftLast() { var scheduler = new TestScheduler(); @@ -251,7 +254,7 @@ public void Merge_EmptyDelayed2_LeftLast() ); } - [Fact] + [TestMethod] public void Merge_EmptyDelayed3_MiddleLast() { var scheduler = new TestScheduler(); @@ -292,7 +295,7 @@ public void Merge_EmptyDelayed3_MiddleLast() ); } - [Fact] + [TestMethod] public void Merge_EmptyNever() { var scheduler = new TestScheduler(); @@ -322,7 +325,7 @@ public void Merge_EmptyNever() ); } - [Fact] + [TestMethod] public void Merge_NeverEmpty() { var scheduler = new TestScheduler(); @@ -352,7 +355,7 @@ public void Merge_NeverEmpty() ); } - [Fact] + [TestMethod] public void Merge_ReturnNever() { var scheduler = new TestScheduler(); @@ -384,7 +387,7 @@ public void Merge_ReturnNever() ); } - [Fact] + [TestMethod] public void Merge_NeverReturn() { var scheduler = new TestScheduler(); @@ -416,7 +419,7 @@ public void Merge_NeverReturn() ); } - [Fact] + [TestMethod] public void Merge_ErrorNever() { var scheduler = new TestScheduler(); @@ -451,7 +454,7 @@ public void Merge_ErrorNever() ); } - [Fact] + [TestMethod] public void Merge_NeverError() { var scheduler = new TestScheduler(); @@ -486,7 +489,7 @@ public void Merge_NeverError() ); } - [Fact] + [TestMethod] public void Merge_EmptyReturn() { var scheduler = new TestScheduler(); @@ -520,7 +523,7 @@ public void Merge_EmptyReturn() ); } - [Fact] + [TestMethod] public void Merge_ReturnEmpty() { var scheduler = new TestScheduler(); @@ -554,7 +557,7 @@ public void Merge_ReturnEmpty() ); } - [Fact] + [TestMethod] public void Merge_Lots2() { var scheduler = new TestScheduler(); @@ -602,7 +605,7 @@ public void Merge_Lots2() ); } - [Fact] + [TestMethod] public void Merge_Lots3() { var scheduler = new TestScheduler(); @@ -659,7 +662,7 @@ public void Merge_Lots3() ); } - [Fact] + [TestMethod] public void Merge_LotsMore() { var inputs = new List>>>(); @@ -714,7 +717,7 @@ orderby n.Time descending Assert.True(res.Messages[resOnNext.Count].Value.Kind == NotificationKind.OnCompleted && res.Messages[resOnNext.Count].Time == lastCompleted.Time, "complete"); } - [Fact] + [TestMethod] public void Merge_ErrorLeft() { var scheduler = new TestScheduler(); @@ -752,7 +755,7 @@ public void Merge_ErrorLeft() ); } - [Fact] + [TestMethod] public void Merge_ErrorCausesDisposal() { var scheduler = new TestScheduler(); @@ -787,7 +790,7 @@ public void Merge_ErrorCausesDisposal() ); } - [Fact] + [TestMethod] public void Merge_ObservableOfObservable_Data() { var scheduler = new TestScheduler(); @@ -873,7 +876,7 @@ public void Merge_ObservableOfObservable_Data() ); } - [Fact] + [TestMethod] public void Merge_ObservableOfObservable_Data_NonOverlapped() { var scheduler = new TestScheduler(); @@ -942,7 +945,7 @@ public void Merge_ObservableOfObservable_Data_NonOverlapped() ); } - [Fact] + [TestMethod] public void Merge_ObservableOfObservable_InnerThrows() { var scheduler = new TestScheduler(); @@ -1014,7 +1017,7 @@ public void Merge_ObservableOfObservable_InnerThrows() ); } - [Fact] + [TestMethod] public void Merge_ObservableOfObservable_OuterThrows() { var scheduler = new TestScheduler(); @@ -1074,25 +1077,25 @@ public void Merge_ObservableOfObservable_OuterThrows() ); } - [Fact] + [TestMethod] public void Merge_Binary_DefaultScheduler() { Assert.True(Observable.Return(1).Merge(Observable.Return(2)).ToEnumerable().OrderBy(x => x).SequenceEqual(new[] { 1, 2 })); } - [Fact] + [TestMethod] public void Merge_Params_DefaultScheduler() { Assert.True(Observable.Merge(Observable.Return(1), Observable.Return(2)).ToEnumerable().OrderBy(x => x).SequenceEqual(new[] { 1, 2 })); } - [Fact] + [TestMethod] public void Merge_IEnumerableOfIObservable_DefaultScheduler() { Assert.True(Observable.Merge((IEnumerable>)new[] { Observable.Return(1), Observable.Return(2) }).ToEnumerable().OrderBy(x => x).SequenceEqual(new[] { 1, 2 })); } - [Fact] + [TestMethod] public void MergeConcat_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Merge(default(IEnumerable>), 1, DummyScheduler.Instance)); @@ -1106,7 +1109,7 @@ public void MergeConcat_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Concat(default(IObservable>))); } - [Fact] + [TestMethod] public void MergeConcat_Enumerable_Scheduler() { var b = Enumerable.Range(1, 3).Select(x => Observable.Range(x * 10, 3)).Merge(1) @@ -1115,7 +1118,7 @@ public void MergeConcat_Enumerable_Scheduler() Assert.True(b); } - [Fact] + [TestMethod] public void MergeConcat_Enumerable() { var b = Enumerable.Range(1, 3).Select(x => Observable.Range(x * 10, 3)).Merge(1, DefaultScheduler.Instance) @@ -1124,7 +1127,7 @@ public void MergeConcat_Enumerable() Assert.True(b); } - [Fact] + [TestMethod] public void MergeConcat_Default() { var b = Observable.Range(1, 3).Select(x => Observable.Range(x * 10, 3)).Concat() @@ -1133,7 +1136,7 @@ public void MergeConcat_Default() Assert.True(b); } - [Fact] + [TestMethod] public void MergeConcat_Basic() { var scheduler = new TestScheduler(); @@ -1218,7 +1221,7 @@ public void MergeConcat_Basic() ); } - [Fact] + [TestMethod] public void MergeConcat_Basic_Long() { var scheduler = new TestScheduler(); @@ -1303,7 +1306,7 @@ public void MergeConcat_Basic_Long() ); } - [Fact] + [TestMethod] public void MergeConcat_Basic_Wide() { var scheduler = new TestScheduler(); @@ -1388,7 +1391,7 @@ public void MergeConcat_Basic_Wide() ); } - [Fact] + [TestMethod] public void MergeConcat_Basic_Late() { var scheduler = new TestScheduler(); @@ -1466,7 +1469,7 @@ public void MergeConcat_Basic_Late() ); } - [Fact] + [TestMethod] public void MergeConcat_Disposed() { var scheduler = new TestScheduler(); @@ -1547,7 +1550,7 @@ public void MergeConcat_Disposed() ); } - [Fact] + [TestMethod] public void MergeConcat_OuterError() { var scheduler = new TestScheduler(); @@ -1622,7 +1625,7 @@ public void MergeConcat_OuterError() ); } - [Fact] + [TestMethod] public void MergeConcat_InnerError() { var scheduler = new TestScheduler(); @@ -1707,7 +1710,7 @@ public void MergeConcat_InnerError() ); } - [Fact] + [TestMethod] public void Merge_Task() { var tss = Observable.Merge(new[] { Task.Factory.StartNew(() => 1), Task.Factory.StartNew(() => 2), Task.Factory.StartNew(() => 3) }.ToObservable()); @@ -1717,7 +1720,7 @@ public void Merge_Task() Assert.True(res.OrderBy(x => x).SequenceEqual(new[] { 1, 2, 3 })); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_RanToCompletion_Async() { var tcss = new TaskCompletionSource[2]; @@ -1739,7 +1742,7 @@ public void Merge_TaskWithCompletionSource_RanToCompletion_Async() lst.OrderBy(x => x).AssertEqual(new[] { 42, 43 }); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_RanToCompletion_Sync() { var tcss = new TaskCompletionSource[2]; @@ -1761,7 +1764,7 @@ public void Merge_TaskWithCompletionSource_RanToCompletion_Sync() lst.OrderBy(x => x).AssertEqual(new[] { 42, 43 }); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_Faulted_Async() { var tcss = new TaskCompletionSource[3]; @@ -1786,7 +1789,7 @@ public void Merge_TaskWithCompletionSource_Faulted_Async() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_Faulted_Sync() { var tcss = new TaskCompletionSource[3]; @@ -1811,7 +1814,7 @@ public void Merge_TaskWithCompletionSource_Faulted_Sync() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_Canceled_Async() { var tcss = new TaskCompletionSource[3]; @@ -1835,7 +1838,7 @@ public void Merge_TaskWithCompletionSource_Canceled_Async() Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_Canceled_Sync() { var tcss = new TaskCompletionSource[3]; @@ -1859,7 +1862,7 @@ public void Merge_TaskWithCompletionSource_Canceled_Sync() Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_InnerCompleteBeforeOuter() { var xs = new Subject(); @@ -1892,7 +1895,7 @@ public void Merge_TaskWithCompletionSource_InnerCompleteBeforeOuter() lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void Merge_TaskWithCompletionSource_OuterCompleteBeforeInner() { var xs = new Subject(); @@ -1924,7 +1927,7 @@ public void Merge_TaskWithCompletionSource_OuterCompleteBeforeInner() lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void Merge_Task_OnError() { var xs = new Subject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinByTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinByTest.cs index def8e41e17..423b9bca2e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinByTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinByTest.cs @@ -8,14 +8,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class MinByTest : ReactiveTest { - [Fact] + [TestMethod] public void MinBy_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.MinBy(default(IObservable), x => x)); @@ -25,7 +26,7 @@ public void MinBy_ArgumentChecking() ReactiveAssert.Throws(() => Observable.MinBy(DummyObservable.Instance, x => x, null)); } - [Fact] + [TestMethod] public void MinBy_Empty() { var scheduler = new TestScheduler(); @@ -49,7 +50,7 @@ public void MinBy_Empty() ); } - [Fact] + [TestMethod] public void MinBy_Return() { var scheduler = new TestScheduler(); @@ -76,7 +77,7 @@ public void MinBy_Return() ); } - [Fact] + [TestMethod] public void MinBy_Some() { var scheduler = new TestScheduler(); @@ -105,7 +106,7 @@ public void MinBy_Some() ); } - [Fact] + [TestMethod] public void MinBy_Multiple() { var scheduler = new TestScheduler(); @@ -138,7 +139,7 @@ public void MinBy_Multiple() ); } - [Fact] + [TestMethod] public void MinBy_Throw() { var ex = new Exception(); @@ -163,7 +164,7 @@ public void MinBy_Throw() ); } - [Fact] + [TestMethod] public void MinBy_Never() { var ex = new Exception(); @@ -186,7 +187,7 @@ public void MinBy_Never() ); } - [Fact] + [TestMethod] public void MinBy_Comparer_Empty() { var scheduler = new TestScheduler(); @@ -210,7 +211,7 @@ public void MinBy_Comparer_Empty() ); } - [Fact] + [TestMethod] public void MinBy_Comparer_Return() { var scheduler = new TestScheduler(); @@ -237,7 +238,7 @@ public void MinBy_Comparer_Return() ); } - [Fact] + [TestMethod] public void MinBy_Comparer_Some() { var scheduler = new TestScheduler(); @@ -266,7 +267,7 @@ public void MinBy_Comparer_Some() ); } - [Fact] + [TestMethod] public void MinBy_Comparer_Throw() { var ex = new Exception(); @@ -291,7 +292,7 @@ public void MinBy_Comparer_Throw() ); } - [Fact] + [TestMethod] public void MinBy_Comparer_Never() { var ex = new Exception(); @@ -314,7 +315,7 @@ public void MinBy_Comparer_Never() ); } - [Fact] + [TestMethod] public void MinBy_SelectorThrows() { var ex = new Exception(); @@ -342,7 +343,7 @@ public void MinBy_SelectorThrows() ); } - [Fact] + [TestMethod] public void MinBy_ComparerThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinTest.cs index 1e26358eaa..df911d78fe 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MinTest.cs @@ -7,14 +7,15 @@ using System.Linq; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class MinTest : ReactiveTest { - [Fact] + [TestMethod] public void Min_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Min(default(IObservable))); @@ -63,7 +64,7 @@ public void Min_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Min(Observable.Empty(), _ => "", default)); } - [Fact] + [TestMethod] public void Min_Int32_Empty() { var scheduler = new TestScheduler(); @@ -86,7 +87,7 @@ public void Min_Int32_Empty() ); } - [Fact] + [TestMethod] public void Min_Int32_Return() { var scheduler = new TestScheduler(); @@ -111,7 +112,7 @@ public void Min_Int32_Return() ); } - [Fact] + [TestMethod] public void Min_Int32_Some() { var scheduler = new TestScheduler(); @@ -138,7 +139,7 @@ public void Min_Int32_Some() ); } - [Fact] + [TestMethod] public void Min_Int32_Throw() { var ex = new Exception(); @@ -163,7 +164,7 @@ public void Min_Int32_Throw() ); } - [Fact] + [TestMethod] public void Min_Int32_Never() { var ex = new Exception(); @@ -186,7 +187,7 @@ public void Min_Int32_Never() ); } - [Fact] + [TestMethod] public void Min_Int64_Empty() { var scheduler = new TestScheduler(); @@ -209,7 +210,7 @@ public void Min_Int64_Empty() ); } - [Fact] + [TestMethod] public void Min_Int64_Return() { var scheduler = new TestScheduler(); @@ -234,7 +235,7 @@ public void Min_Int64_Return() ); } - [Fact] + [TestMethod] public void Min_Int64_Some() { var scheduler = new TestScheduler(); @@ -261,7 +262,7 @@ public void Min_Int64_Some() ); } - [Fact] + [TestMethod] public void Min_Int64_Throw() { var ex = new Exception(); @@ -286,7 +287,7 @@ public void Min_Int64_Throw() ); } - [Fact] + [TestMethod] public void Min_Int64_Never() { var ex = new Exception(); @@ -309,7 +310,7 @@ public void Min_Int64_Never() ); } - [Fact] + [TestMethod] public void Min_Float_Empty() { var scheduler = new TestScheduler(); @@ -332,7 +333,7 @@ public void Min_Float_Empty() ); } - [Fact] + [TestMethod] public void Min_Float_Return() { var scheduler = new TestScheduler(); @@ -357,7 +358,7 @@ public void Min_Float_Return() ); } - [Fact] + [TestMethod] public void Min_Float_Some() { var scheduler = new TestScheduler(); @@ -384,7 +385,7 @@ public void Min_Float_Some() ); } - [Fact] + [TestMethod] public void Min_Float_Throw() { var ex = new Exception(); @@ -409,7 +410,7 @@ public void Min_Float_Throw() ); } - [Fact] + [TestMethod] public void Min_Float_Never() { var ex = new Exception(); @@ -432,7 +433,7 @@ public void Min_Float_Never() ); } - [Fact] + [TestMethod] public void Min_Double_Empty() { var scheduler = new TestScheduler(); @@ -455,7 +456,7 @@ public void Min_Double_Empty() ); } - [Fact] + [TestMethod] public void Min_Double_Return() { var scheduler = new TestScheduler(); @@ -480,7 +481,7 @@ public void Min_Double_Return() ); } - [Fact] + [TestMethod] public void Min_Double_Some() { var scheduler = new TestScheduler(); @@ -507,7 +508,7 @@ public void Min_Double_Some() ); } - [Fact] + [TestMethod] public void Min_Double_Throw() { var ex = new Exception(); @@ -532,7 +533,7 @@ public void Min_Double_Throw() ); } - [Fact] + [TestMethod] public void Min_Double_Never() { var ex = new Exception(); @@ -555,7 +556,7 @@ public void Min_Double_Never() ); } - [Fact] + [TestMethod] public void Min_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -578,7 +579,7 @@ public void Min_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Min_Decimal_Return() { var scheduler = new TestScheduler(); @@ -603,7 +604,7 @@ public void Min_Decimal_Return() ); } - [Fact] + [TestMethod] public void Min_Decimal_Some() { var scheduler = new TestScheduler(); @@ -630,7 +631,7 @@ public void Min_Decimal_Some() ); } - [Fact] + [TestMethod] public void Min_Decimal_Throw() { var ex = new Exception(); @@ -655,7 +656,7 @@ public void Min_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Min_Decimal_Never() { var ex = new Exception(); @@ -678,7 +679,7 @@ public void Min_Decimal_Never() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int32_Empty() { var scheduler = new TestScheduler(); @@ -702,7 +703,7 @@ public void Min_Nullable_Int32_Empty() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int32_Return() { var scheduler = new TestScheduler(); @@ -727,7 +728,7 @@ public void Min_Nullable_Int32_Return() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int32_Some1() { var scheduler = new TestScheduler(); @@ -754,7 +755,7 @@ public void Min_Nullable_Int32_Some1() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int32_Some2() { var scheduler = new TestScheduler(); @@ -781,7 +782,7 @@ public void Min_Nullable_Int32_Some2() ); } - [Fact] + [TestMethod] public void Min_Nullable_GeneralNullableMinTest_LhsNull() { var scheduler = new TestScheduler(); @@ -807,7 +808,7 @@ public void Min_Nullable_GeneralNullableMinTest_LhsNull() ); } - [Fact] + [TestMethod] public void Min_Nullable_GeneralNullableMinTest_RhsNull() { var scheduler = new TestScheduler(); @@ -833,7 +834,7 @@ public void Min_Nullable_GeneralNullableMinTest_RhsNull() ); } - [Fact] + [TestMethod] public void Min_Nullable_GeneralNullableMinTest_Less() { var scheduler = new TestScheduler(); @@ -859,7 +860,7 @@ public void Min_Nullable_GeneralNullableMinTest_Less() ); } - [Fact] + [TestMethod] public void Min_Nullable_GeneralNullableMinTest_Greater() { var scheduler = new TestScheduler(); @@ -885,7 +886,7 @@ public void Min_Nullable_GeneralNullableMinTest_Greater() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int32_Throw() { var ex = new Exception(); @@ -910,7 +911,7 @@ public void Min_Nullable_Int32_Throw() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int32_Never() { var ex = new Exception(); @@ -933,7 +934,7 @@ public void Min_Nullable_Int32_Never() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int64_Empty() { var scheduler = new TestScheduler(); @@ -957,7 +958,7 @@ public void Min_Nullable_Int64_Empty() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int64_Return() { var scheduler = new TestScheduler(); @@ -982,7 +983,7 @@ public void Min_Nullable_Int64_Return() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int64_Some1() { var scheduler = new TestScheduler(); @@ -1009,7 +1010,7 @@ public void Min_Nullable_Int64_Some1() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int64_Some2() { var scheduler = new TestScheduler(); @@ -1036,7 +1037,7 @@ public void Min_Nullable_Int64_Some2() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int64_Throw() { var ex = new Exception(); @@ -1061,7 +1062,7 @@ public void Min_Nullable_Int64_Throw() ); } - [Fact] + [TestMethod] public void Min_Nullable_Int64_Never() { var ex = new Exception(); @@ -1084,7 +1085,7 @@ public void Min_Nullable_Int64_Never() ); } - [Fact] + [TestMethod] public void Min_Nullable_Float_Empty() { var scheduler = new TestScheduler(); @@ -1108,7 +1109,7 @@ public void Min_Nullable_Float_Empty() ); } - [Fact] + [TestMethod] public void Min_Nullable_Float_Return() { var scheduler = new TestScheduler(); @@ -1133,7 +1134,7 @@ public void Min_Nullable_Float_Return() ); } - [Fact] + [TestMethod] public void Min_Nullable_Float_Some1() { var scheduler = new TestScheduler(); @@ -1160,7 +1161,7 @@ public void Min_Nullable_Float_Some1() ); } - [Fact] + [TestMethod] public void Min_Nullable_Float_Some2() { var scheduler = new TestScheduler(); @@ -1187,7 +1188,7 @@ public void Min_Nullable_Float_Some2() ); } - [Fact] + [TestMethod] public void Min_Nullable_Float_Throw() { var ex = new Exception(); @@ -1212,7 +1213,7 @@ public void Min_Nullable_Float_Throw() ); } - [Fact] + [TestMethod] public void Min_Nullable_Float_Never() { var ex = new Exception(); @@ -1235,7 +1236,7 @@ public void Min_Nullable_Float_Never() ); } - [Fact] + [TestMethod] public void Min_Nullable_Double_Empty() { var scheduler = new TestScheduler(); @@ -1259,7 +1260,7 @@ public void Min_Nullable_Double_Empty() ); } - [Fact] + [TestMethod] public void Min_Nullable_Double_Return() { var scheduler = new TestScheduler(); @@ -1284,7 +1285,7 @@ public void Min_Nullable_Double_Return() ); } - [Fact] + [TestMethod] public void Min_Nullable_Double_Some1() { var scheduler = new TestScheduler(); @@ -1311,7 +1312,7 @@ public void Min_Nullable_Double_Some1() ); } - [Fact] + [TestMethod] public void Min_Nullable_Double_Some2() { var scheduler = new TestScheduler(); @@ -1338,7 +1339,7 @@ public void Min_Nullable_Double_Some2() ); } - [Fact] + [TestMethod] public void Min_Nullable_Double_Throw() { var ex = new Exception(); @@ -1363,7 +1364,7 @@ public void Min_Nullable_Double_Throw() ); } - [Fact] + [TestMethod] public void Min_Nullable_Double_Never() { var ex = new Exception(); @@ -1386,7 +1387,7 @@ public void Min_Nullable_Double_Never() ); } - [Fact] + [TestMethod] public void Min_Nullable_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -1410,7 +1411,7 @@ public void Min_Nullable_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Min_Nullable_Decimal_Return() { var scheduler = new TestScheduler(); @@ -1435,7 +1436,7 @@ public void Min_Nullable_Decimal_Return() ); } - [Fact] + [TestMethod] public void Min_Nullable_Decimal_Some1() { var scheduler = new TestScheduler(); @@ -1462,7 +1463,7 @@ public void Min_Nullable_Decimal_Some1() ); } - [Fact] + [TestMethod] public void Min_Nullable_Decimal_Some2() { var scheduler = new TestScheduler(); @@ -1489,7 +1490,7 @@ public void Min_Nullable_Decimal_Some2() ); } - [Fact] + [TestMethod] public void Min_Nullable_Decimal_Throw() { var ex = new Exception(); @@ -1514,7 +1515,7 @@ public void Min_Nullable_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Min_Nullable_Decimal_Never() { var ex = new Exception(); @@ -1537,7 +1538,7 @@ public void Min_Nullable_Decimal_Never() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Empty() { var scheduler = new TestScheduler(); @@ -1568,7 +1569,7 @@ public void MinOfT_Reference_Empty() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Empty() { var scheduler = new TestScheduler(); @@ -1591,7 +1592,7 @@ public void MinOfT_Value_Empty() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Return() { var scheduler = new TestScheduler(); @@ -1616,7 +1617,7 @@ public void MinOfT_Reference_Return() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Return() { var scheduler = new TestScheduler(); @@ -1641,7 +1642,7 @@ public void MinOfT_Value_Return() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Some() { var scheduler = new TestScheduler(); @@ -1668,7 +1669,7 @@ public void MinOfT_Reference_Some() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Some() { var scheduler = new TestScheduler(); @@ -1695,7 +1696,7 @@ public void MinOfT_Value_Some() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Throw() { var ex = new Exception(); @@ -1720,7 +1721,7 @@ public void MinOfT_Reference_Throw() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Throw() { var ex = new Exception(); @@ -1745,7 +1746,7 @@ public void MinOfT_Value_Throw() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Never() { var ex = new Exception(); @@ -1768,7 +1769,7 @@ public void MinOfT_Reference_Never() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Never() { var ex = new Exception(); @@ -1791,7 +1792,7 @@ public void MinOfT_Value_Never() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Comparer_Empty() { var scheduler = new TestScheduler(); @@ -1822,7 +1823,7 @@ public void MinOfT_Reference_Comparer_Empty() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Comparer_Empty() { var scheduler = new TestScheduler(); @@ -1845,7 +1846,7 @@ public void MinOfT_Value_Comparer_Empty() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Comparer_Return() { var scheduler = new TestScheduler(); @@ -1870,7 +1871,7 @@ public void MinOfT_Reference_Comparer_Return() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Comparer_Return() { var scheduler = new TestScheduler(); @@ -1895,7 +1896,7 @@ public void MinOfT_Value_Comparer_Return() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Comparer_Some() { var scheduler = new TestScheduler(); @@ -1922,7 +1923,7 @@ public void MinOfT_Reference_Comparer_Some() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Comparer_Some() { var scheduler = new TestScheduler(); @@ -1949,7 +1950,7 @@ public void MinOfT_Value_Comparer_Some() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Comparer_Throw() { var ex = new Exception(); @@ -1974,7 +1975,7 @@ public void MinOfT_Reference_Comparer_Throw() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Comparer_Throw() { var ex = new Exception(); @@ -1999,7 +2000,7 @@ public void MinOfT_Value_Comparer_Throw() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_Comparer_Never() { var ex = new Exception(); @@ -2022,7 +2023,7 @@ public void MinOfT_Reference_Comparer_Never() ); } - [Fact] + [TestMethod] public void MinOfT_Value_Comparer_Never() { var ex = new Exception(); @@ -2045,7 +2046,7 @@ public void MinOfT_Value_Comparer_Never() ); } - [Fact] + [TestMethod] public void MinOfT_Reference_ComparerThrows() { var ex = new Exception(); @@ -2073,7 +2074,7 @@ public void MinOfT_Reference_ComparerThrows() ); } - [Fact] + [TestMethod] public void MinOfT_Value_ComparerThrows() { var ex = new Exception(); @@ -2101,7 +2102,7 @@ public void MinOfT_Value_ComparerThrows() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Int32() { var scheduler = new TestScheduler(); @@ -2125,7 +2126,7 @@ public void Min_Selector_Regular_Int32() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Int64() { var scheduler = new TestScheduler(); @@ -2149,7 +2150,7 @@ public void Min_Selector_Regular_Int64() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Single() { var scheduler = new TestScheduler(); @@ -2173,7 +2174,7 @@ public void Min_Selector_Regular_Single() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Double() { var scheduler = new TestScheduler(); @@ -2197,7 +2198,7 @@ public void Min_Selector_Regular_Double() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Decimal() { var scheduler = new TestScheduler(); @@ -2221,7 +2222,7 @@ public void Min_Selector_Regular_Decimal() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Int32_Nullable() { var scheduler = new TestScheduler(); @@ -2245,7 +2246,7 @@ public void Min_Selector_Regular_Int32_Nullable() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Int64_Nullable() { var scheduler = new TestScheduler(); @@ -2269,7 +2270,7 @@ public void Min_Selector_Regular_Int64_Nullable() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Single_Nullable() { var scheduler = new TestScheduler(); @@ -2293,7 +2294,7 @@ public void Min_Selector_Regular_Single_Nullable() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Double_Nullable() { var scheduler = new TestScheduler(); @@ -2317,7 +2318,7 @@ public void Min_Selector_Regular_Double_Nullable() ); } - [Fact] + [TestMethod] public void Min_Selector_Regular_Decimal_Nullable() { var scheduler = new TestScheduler(); @@ -2341,7 +2342,7 @@ public void Min_Selector_Regular_Decimal_Nullable() ); } - [Fact] + [TestMethod] public void MinOfT_Selector_Regular() { var scheduler = new TestScheduler(); @@ -2365,7 +2366,7 @@ public void MinOfT_Selector_Regular() ); } - [Fact] + [TestMethod] public void MinOfT_Selector_Regular_Comparer() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MostRecentTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MostRecentTest.cs index e0b50a323c..009272a30c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MostRecentTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MostRecentTest.cs @@ -10,20 +10,23 @@ 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 MostRecentTest : ReactiveTest { - [Fact] + [TestMethod] public void MostRecent_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.MostRecent(default, 1)); } - [Fact] + [TestMethod] public void MostRecent1() { var evt = new AutoResetEvent(false); @@ -68,7 +71,7 @@ public void MostRecent1() Assert.False(res.MoveNext()); } - [Fact] + [TestMethod] public void MostRecent2() { var scheduler = new TestScheduler(); @@ -157,7 +160,7 @@ public void MostRecent2() o2.AssertEqual(0, 6, 6, 7); } - [Fact] + [TestMethod] public void MostRecent_Error() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MulticastTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MulticastTest.cs index b715c2e44f..94fe80a029 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MulticastTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/MulticastTest.cs @@ -9,14 +9,15 @@ using System.Reactive.Subjects; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class MulticastTest : ReactiveTest { - [Fact] + [TestMethod] public void Multicast_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Multicast(null, new Subject())); @@ -26,7 +27,7 @@ public void Multicast_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Multicast(DummyObservable.Instance, () => new Subject(), null)); } - [Fact] + [TestMethod] public void Multicast_Hot_1() { var scheduler = new TestScheduler(); @@ -68,7 +69,7 @@ public void Multicast_Hot_1() ); } - [Fact] + [TestMethod] public void Multicast_Hot_2() { var scheduler = new TestScheduler(); @@ -110,7 +111,7 @@ public void Multicast_Hot_2() ); } - [Fact] + [TestMethod] public void Multicast_Hot_3() { var scheduler = new TestScheduler(); @@ -156,7 +157,7 @@ public void Multicast_Hot_3() ); } - [Fact] + [TestMethod] public void Multicast_Hot_4() { var scheduler = new TestScheduler(); @@ -204,7 +205,7 @@ public void Multicast_Hot_4() ); } - [Fact] + [TestMethod] public void Multicast_Hot_5() { var scheduler = new TestScheduler(); @@ -245,7 +246,7 @@ public void Multicast_Hot_5() ); } - [Fact] + [TestMethod] public void Multicast_Hot_6() { var scheduler = new TestScheduler(); @@ -284,7 +285,7 @@ public void Multicast_Hot_6() ); } - [Fact] + [TestMethod] public void Multicast_Cold_Completed() { var scheduler = new TestScheduler(); @@ -319,7 +320,7 @@ public void Multicast_Cold_Completed() ); } - [Fact] + [TestMethod] public void Multicast_Cold_Error() { var scheduler = new TestScheduler(); @@ -356,7 +357,7 @@ public void Multicast_Cold_Error() ); } - [Fact] + [TestMethod] public void Multicast_Cold_Dispose() { var scheduler = new TestScheduler(); @@ -389,7 +390,7 @@ public void Multicast_Cold_Dispose() ); } - [Fact] + [TestMethod] public void Multicast_Cold_Zip() { var scheduler = new TestScheduler(); @@ -424,7 +425,7 @@ public void Multicast_Cold_Zip() ); } - [Fact] + [TestMethod] public void Multicast_SubjectSelectorThrows() { var ex = new Exception(); @@ -449,7 +450,7 @@ public void Multicast_SubjectSelectorThrows() ); } - [Fact] + [TestMethod] public void Multicast_SelectorThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NeverTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NeverTest.cs index 96195e0e84..139247b8af 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NeverTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NeverTest.cs @@ -5,21 +5,22 @@ using System; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class NeverTest : ReactiveTest { - [Fact] + [TestMethod] public void Never_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Never().Subscribe(null)); ReactiveAssert.Throws(() => Observable.Never(42).Subscribe(null)); } - [Fact] + [TestMethod] public void Never_Basic() { var scheduler = new TestScheduler(); @@ -36,7 +37,7 @@ public void Never_Basic() ); } - [Fact] + [TestMethod] public void Never_Basic_Witness() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NextTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NextTest.cs index 3833f00b00..5f71c1ced9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NextTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/NextTest.cs @@ -12,20 +12,23 @@ 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 NextTest : ReactiveTest { - [Fact] + [TestMethod] public void Next_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Next(default(IObservable))); } - [Fact] + [TestMethod] public void Next1() { var evt = new AutoResetEvent(false); @@ -65,7 +68,7 @@ void release() => Task.Run(async () => } - [Fact] + [TestMethod] public void Next2() { var scheduler = new TestScheduler(); @@ -107,7 +110,7 @@ public void Next2() ); } - [Fact] + [TestMethod] public void Next_DoesNotBlock() { var evt = new ManualResetEvent(false); @@ -121,7 +124,7 @@ public void Next_DoesNotBlock() Assert.False(e.MoveNext()); } - [Fact] + [TestMethod] public void Next_SomeResults() { var xs = Observable.Range(0, 100, Scheduler.Default); @@ -133,7 +136,7 @@ public void Next_SomeResults() } #if !NO_THREAD - [Fact] + [TestMethod] public void Next_Error() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ObserveOnTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ObserveOnTest.cs index 65cc06a9fa..9281112c9e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ObserveOnTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ObserveOnTest.cs @@ -12,7 +12,7 @@ using System.Threading; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; #if HAS_DISPATCHER using System.Windows.Threading; @@ -22,13 +22,16 @@ using System.Windows.Forms; #endif +using Assert = Xunit.Assert; + namespace ReactiveTests.Tests { + [TestClass] public class ObserveOnTest : TestBase { #region + TestBase + - [Fact] + [TestMethod] public void ObserveOn_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -54,7 +57,7 @@ public void ObserveOn_ArgumentChecking() } #if HAS_WINFORMS - [Fact] + [TestMethod] public void ObserveOn_Control() { bool okay = true; @@ -75,7 +78,7 @@ public void ObserveOn_Control() Assert.True(okay); } - [Fact] + [TestMethod] public void ObserveOn_ControlScheduler() { bool okay = true; @@ -97,7 +100,7 @@ public void ObserveOn_ControlScheduler() } #endif #if HAS_DISPATCHER - [Fact] + [TestMethod] [Asynchronous] public void ObserveOn_Dispatcher() { @@ -118,7 +121,7 @@ public void ObserveOn_Dispatcher() } } - [Fact] + [TestMethod] [Asynchronous] public void ObserveOn_DispatcherScheduler() { @@ -139,7 +142,7 @@ public void ObserveOn_DispatcherScheduler() } } - [Fact] + [TestMethod] [Asynchronous] public void ObserveOn_CurrentDispatcher() { @@ -163,7 +166,7 @@ public void ObserveOn_CurrentDispatcher() } } - [Fact] + [TestMethod] [Asynchronous] public void ObserveOn_Error() { @@ -200,18 +203,19 @@ public void ObserveOn_Error() } + [TestClass] public class ObserveOnReactiveTest : ReactiveTest { private static TimeSpan MaxWaitTime = TimeSpan.FromSeconds(10); - [Fact] + [TestMethod] public void ObserveOn_Scheduler_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ObserveOn(default(IObservable), DummyScheduler.Instance)); ReactiveAssert.Throws(() => Observable.ObserveOn(DummyObservable.Instance, default(IScheduler))); } - [Fact] + [TestMethod] public void ObserveOn_Scheduler_Completed() { var scheduler = new TestScheduler(); @@ -254,7 +258,7 @@ public void ObserveOn_Scheduler_Completed() #endif } - [Fact] + [TestMethod] public void ObserveOn_Scheduler_Error() { var scheduler = new TestScheduler(); @@ -298,7 +302,7 @@ public void ObserveOn_Scheduler_Error() #endif } - [Fact] + [TestMethod] public void ObserveOn_Scheduler_Dispose() { var scheduler = new TestScheduler(); @@ -328,7 +332,7 @@ public void ObserveOn_Scheduler_Dispose() ); } - [Fact] + [TestMethod] public void ObserveOn_Scheduler_SameTime() { var scheduler = new TestScheduler(); @@ -352,7 +356,7 @@ public void ObserveOn_Scheduler_SameTime() ); } - [Fact] + [TestMethod] public void ObserveOn_Scheduler_OnNextThrows() { var e = new ManualResetEvent(false); @@ -414,7 +418,7 @@ public IDisposable Schedule(TState state, DateTimeOffset dueTime, Func 0 && !lst.Contains(4)); } - [Fact] + [TestMethod] public void ObserveOn_LongRunning_OnNextThrows() { var started = default(ManualResetEvent); @@ -596,7 +600,7 @@ public void ObserveOn_LongRunning_OnNextThrows() } #endif - [Fact] + [TestMethod] public void ObserveOn_SynchronizationContext_Simple() { var scheduler = new TestScheduler(); @@ -628,7 +632,7 @@ public void ObserveOn_SynchronizationContext_Simple() ); } - [Fact] + [TestMethod] public void ObserveOn_EventLoop_Long() { using var _scheduler1 = new EventLoopScheduler(); @@ -642,7 +646,7 @@ public void ObserveOn_EventLoop_Long() Assert.True(cde.Wait(MaxWaitTime), "Timeout!"); } - [Fact] + [TestMethod] public void ObserveOn_LongRunning_SameThread() { var scheduler = TaskPoolScheduler.Default; @@ -666,7 +670,7 @@ public void ObserveOn_LongRunning_SameThread() Assert.Equal(1, threads.Count); } - [Fact] + [TestMethod] public void ObserveOn_LongRunning_DisableOptimizations() { var scheduler = TaskPoolScheduler.Default.DisableOptimizations(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OfTypeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OfTypeTest.cs index 1c37fe3c13..93fc1878db 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OfTypeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OfTypeTest.cs @@ -7,21 +7,22 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class OfTypeTest : ReactiveTest { - [Fact] + [TestMethod] public void OfType_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.OfType(default)); ReactiveAssert.Throws(() => Observable.OfType(DummyObservable.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void OfType_Complete() { var scheduler = new TestScheduler(); @@ -63,7 +64,7 @@ public void OfType_Complete() ); } - [Fact] + [TestMethod] public void OfType_Error() { var scheduler = new TestScheduler(); @@ -107,7 +108,7 @@ public void OfType_Error() ); } - [Fact] + [TestMethod] public void OfType_Dispose() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OnErrorResumeNextTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OnErrorResumeNextTest.cs index fe56e9b372..92d6420ef1 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OnErrorResumeNextTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/OnErrorResumeNextTest.cs @@ -10,14 +10,17 @@ 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 OnErrorResumeNextTest : ReactiveTest { - [Fact] + [TestMethod] public void OnErrorResumeNext_ArgumentChecking() { var xs = DummyObservable.Instance; @@ -30,7 +33,7 @@ public void OnErrorResumeNext_ArgumentChecking() ReactiveAssert.Throws(() => Observable.OnErrorResumeNext(xs, null)); } - [Fact] + [TestMethod] public void OnErrorResumeNext_IEofIO_GetEnumeratorThrows() { var ex = new Exception(); @@ -48,7 +51,7 @@ public void OnErrorResumeNext_IEofIO_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_IEofIO() { var scheduler = new TestScheduler(); @@ -104,7 +107,7 @@ public void OnErrorResumeNext_IEofIO() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_NoErrors() { var scheduler = new TestScheduler(); @@ -141,7 +144,7 @@ public void OnErrorResumeNext_NoErrors() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_Error() { var scheduler = new TestScheduler(); @@ -178,7 +181,7 @@ public void OnErrorResumeNext_Error() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_ErrorMultiple() { var scheduler = new TestScheduler(); @@ -221,7 +224,7 @@ public void OnErrorResumeNext_ErrorMultiple() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_EmptyReturnThrowAndMore() { var scheduler = new TestScheduler(); @@ -284,7 +287,7 @@ public void OnErrorResumeNext_EmptyReturnThrowAndMore() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_LastIsntSpecial() { var scheduler = new TestScheduler(); @@ -319,7 +322,7 @@ public void OnErrorResumeNext_LastIsntSpecial() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_SingleSourceDoesntThrow() { var scheduler = new TestScheduler(); @@ -343,7 +346,7 @@ public void OnErrorResumeNext_SingleSourceDoesntThrow() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_EndWithNever() { var scheduler = new TestScheduler(); @@ -377,7 +380,7 @@ public void OnErrorResumeNext_EndWithNever() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_StartWithNever() { var scheduler = new TestScheduler(); @@ -409,7 +412,7 @@ public void OnErrorResumeNext_StartWithNever() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_DefaultScheduler_Binary() { var evt = new ManualResetEvent(false); @@ -424,7 +427,7 @@ public void OnErrorResumeNext_DefaultScheduler_Binary() Assert.Equal(3, sum); } - [Fact] + [TestMethod] public void OnErrorResumeNext_DefaultScheduler_Nary() { var evt = new ManualResetEvent(false); @@ -439,7 +442,7 @@ public void OnErrorResumeNext_DefaultScheduler_Nary() Assert.Equal(6, sum); } - [Fact] + [TestMethod] public void OnErrorResumeNext_DefaultScheduler_NaryEnumerable() { var evt = new ManualResetEvent(false); @@ -456,7 +459,7 @@ public void OnErrorResumeNext_DefaultScheduler_NaryEnumerable() Assert.Equal(6, sum); } - [Fact] + [TestMethod] public void OnErrorResumeNext_IteratorThrows() { var scheduler = new TestScheduler(); @@ -471,7 +474,7 @@ public void OnErrorResumeNext_IteratorThrows() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_EnumerableThrows() { var scheduler = new TestScheduler(); @@ -511,7 +514,7 @@ private IEnumerable> GetObservablesForOnErrorResumeNextThrow(IO throw ex; } - [Fact] + [TestMethod] public void OnErrorResumeNext_EnumerableTiming() { var scheduler = new TestScheduler(); @@ -580,7 +583,7 @@ public void OnErrorResumeNext_EnumerableTiming() ); } - [Fact] + [TestMethod] public void OnErrorResumeNext_Enumerable_Dispose() { var scheduler = new TestScheduler(); @@ -631,7 +634,7 @@ public void OnErrorResumeNext_Enumerable_Dispose() } #if !NO_PERF - [Fact] + [TestMethod] public void OnErrorResumeNext_TailRecursive1() { var create = 0L; @@ -668,7 +671,7 @@ public void OnErrorResumeNext_TailRecursive1() } #if HAS_STACKTRACE && !NO_THREAD - [Fact] + [TestMethod] public void OnErrorResumeNext_TailRecursive2() { var f = default(Func>); @@ -681,7 +684,7 @@ public void OnErrorResumeNext_TailRecursive2() } #endif - [Fact] + [TestMethod] public void OnErrorResumeNext_TailRecursive3() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PrependTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PrependTest.cs index 2664aa9332..e8642b5eae 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PrependTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PrependTest.cs @@ -6,14 +6,15 @@ using System.Linq; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class PrependTest : ReactiveTest { - [Fact] + [TestMethod] public void Prepend_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -25,7 +26,7 @@ public void Prepend_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Prepend(someObservable, 1, default)); } - [Fact] + [TestMethod] public void Prepend() { var scheduler = new TestScheduler(); @@ -47,7 +48,7 @@ public void Prepend() ); } - [Fact] + [TestMethod] public void Prepend_Scheduler() { var scheduler = new TestScheduler(); @@ -69,7 +70,7 @@ public void Prepend_Scheduler() ); } - [Fact] + [TestMethod] public void Prepend_Many() { var scheduler = new TestScheduler(); @@ -93,7 +94,7 @@ public void Prepend_Many() ); } - [Fact] + [TestMethod] public void Prepend_Many_Take() { var scheduler = new TestScheduler(); @@ -116,7 +117,7 @@ public void Prepend_Many_Take() } - [Fact] + [TestMethod] public void Prepend_Many_Scheduler() { var scheduler = new TestScheduler(); @@ -140,7 +141,7 @@ public void Prepend_Many_Scheduler() ); } - [Fact] + [TestMethod] public void Prepend_Many_Take_Scheduler() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishLastTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishLastTest.cs index 653b9bf838..da8c61c06b 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishLastTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishLastTest.cs @@ -8,14 +8,17 @@ 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 PublishLastTest : ReactiveTest { - [Fact] + [TestMethod] public void PublishLast_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -26,7 +29,7 @@ public void PublishLast_ArgumentChecking() ReactiveAssert.Throws(() => Observable.PublishLast(someObservable, null)); } - [Fact] + [TestMethod] public void PublishLast_Basic() { var scheduler = new TestScheduler(); @@ -78,7 +81,7 @@ public void PublishLast_Basic() ); } - [Fact] + [TestMethod] public void PublishLast_Error() { var scheduler = new TestScheduler(); @@ -129,7 +132,7 @@ public void PublishLast_Error() ); } - [Fact] + [TestMethod] public void PublishLast_Complete() { var scheduler = new TestScheduler(); @@ -179,7 +182,7 @@ public void PublishLast_Complete() ); } - [Fact] + [TestMethod] public void PublishLast_Dispose() { var scheduler = new TestScheduler(); @@ -231,7 +234,7 @@ public void PublishLast_Dispose() ); } - [Fact] + [TestMethod] public void PublishLast_MultipleConnections() { var xs = Observable.Never(); @@ -252,7 +255,7 @@ public void PublishLast_MultipleConnections() connection3.Dispose(); } - [Fact] + [TestMethod] public void PublishLastLambda_Zip_Complete() { var scheduler = new TestScheduler(); @@ -288,7 +291,7 @@ public void PublishLastLambda_Zip_Complete() ); } - [Fact] + [TestMethod] public void PublishLastLambda_Zip_Error() { var scheduler = new TestScheduler(); @@ -325,7 +328,7 @@ public void PublishLastLambda_Zip_Error() ); } - [Fact] + [TestMethod] public void PublishLastLambda_Zip_Dispose() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishTest.cs index c90dcf01fb..35eeaef2b9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/PublishTest.cs @@ -8,13 +8,16 @@ 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 PublishTest : ReactiveTest { - [Fact] + [TestMethod] public void Publish_Cold_Zip() { var scheduler = new TestScheduler(); @@ -49,7 +52,7 @@ public void Publish_Cold_Zip() ); } - [Fact] + [TestMethod] public void Publish_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -59,7 +62,7 @@ public void Publish_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Publish(someObservable, null)); } - [Fact] + [TestMethod] public void Publish_Basic() { var scheduler = new TestScheduler(); @@ -116,7 +119,7 @@ public void Publish_Basic() ); } - [Fact] + [TestMethod] public void Publish_Error() { var scheduler = new TestScheduler(); @@ -173,7 +176,7 @@ public void Publish_Error() ); } - [Fact] + [TestMethod] public void Publish_Complete() { var scheduler = new TestScheduler(); @@ -228,7 +231,7 @@ public void Publish_Complete() ); } - [Fact] + [TestMethod] public void Publish_Dispose() { var scheduler = new TestScheduler(); @@ -281,7 +284,7 @@ public void Publish_Dispose() ); } - [Fact] + [TestMethod] public void Publish_MultipleConnections() { var xs = Observable.Never(); @@ -302,7 +305,7 @@ public void Publish_MultipleConnections() connection3.Dispose(); } - [Fact] + [TestMethod] public void PublishLambda_Zip_Complete() { var scheduler = new TestScheduler(); @@ -348,7 +351,7 @@ public void PublishLambda_Zip_Complete() ); } - [Fact] + [TestMethod] public void PublishLambda_Zip_Error() { var scheduler = new TestScheduler(); @@ -396,7 +399,7 @@ public void PublishLambda_Zip_Error() ); } - [Fact] + [TestMethod] public void PublishLambda_Zip_Dispose() { var scheduler = new TestScheduler(); @@ -440,7 +443,7 @@ public void PublishLambda_Zip_Dispose() ); } - [Fact] + [TestMethod] public void PublishWithInitialValue_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -450,7 +453,7 @@ public void PublishWithInitialValue_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Publish(someObservable, default(Func, IObservable>), 1)); } - [Fact] + [TestMethod] public void PublishWithInitialValue_SanityCheck() { var someObservable = Observable.Empty(); @@ -458,7 +461,7 @@ public void PublishWithInitialValue_SanityCheck() Observable.Publish(Observable.Range(1, 10), x => x, 0).AssertEqual(Observable.Range(0, 11)); } - [Fact] + [TestMethod] public void PublishWithInitialValue_Basic() { var scheduler = new TestScheduler(); @@ -516,7 +519,7 @@ public void PublishWithInitialValue_Basic() ); } - [Fact] + [TestMethod] public void PublishWithInitialValue_Error() { var scheduler = new TestScheduler(); @@ -574,7 +577,7 @@ public void PublishWithInitialValue_Error() ); } - [Fact] + [TestMethod] public void PublishWithInitialValue_Complete() { var scheduler = new TestScheduler(); @@ -630,7 +633,7 @@ public void PublishWithInitialValue_Complete() ); } - [Fact] + [TestMethod] public void PublishWithInitialValue_Dispose() { var scheduler = new TestScheduler(); @@ -684,7 +687,7 @@ public void PublishWithInitialValue_Dispose() ); } - [Fact] + [TestMethod] public void PublishWithInitialValue_MultipleConnections() { var xs = Observable.Never(); @@ -705,7 +708,7 @@ public void PublishWithInitialValue_MultipleConnections() connection3.Dispose(); } - [Fact] + [TestMethod] public void PublishWithInitialValueLambda_Zip_Complete() { var scheduler = new TestScheduler(); @@ -752,7 +755,7 @@ public void PublishWithInitialValueLambda_Zip_Complete() ); } - [Fact] + [TestMethod] public void PublishWithInitialValueLambda_Zip_Error() { var scheduler = new TestScheduler(); @@ -801,7 +804,7 @@ public void PublishWithInitialValueLambda_Zip_Error() ); } - [Fact] + [TestMethod] public void PublishWithInitialValueLambda_Zip_Dispose() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RangeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RangeTest.cs index 0ccf5a5fb4..aa6cd1c779 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RangeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RangeTest.cs @@ -11,14 +11,17 @@ 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 RangeTest : ReactiveTest { - [Fact] + [TestMethod] public void Range_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Range(0, 0, null)); @@ -26,7 +29,7 @@ public void Range_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Range(int.MaxValue, 2, DummyScheduler.Instance)); } - [Fact] + [TestMethod] public void Range_Zero() { var scheduler = new TestScheduler(); @@ -40,7 +43,7 @@ public void Range_Zero() ); } - [Fact] + [TestMethod] public void Range_One() { var scheduler = new TestScheduler(); @@ -55,7 +58,7 @@ public void Range_One() ); } - [Fact] + [TestMethod] public void Range_Five() { var scheduler = new TestScheduler(); @@ -74,7 +77,7 @@ public void Range_Five() ); } - [Fact] + [TestMethod] public void Range_Boundaries() { var scheduler = new TestScheduler(); @@ -89,7 +92,7 @@ public void Range_Boundaries() ); } - [Fact] + [TestMethod] public void Range_Dispose() { var scheduler = new TestScheduler(); @@ -106,14 +109,14 @@ public void Range_Dispose() ); } - [Fact] + [TestMethod] public void Range_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Range(0, -1)); ReactiveAssert.Throws(() => Observable.Range(int.MaxValue, 2)); } - [Fact] + [TestMethod] public void Range_Default() { for (var i = 0; i < 100; i++) @@ -123,7 +126,7 @@ public void Range_Default() } #if !NO_PERF - [Fact] + [TestMethod] public void Range_LongRunning1() { var start = default(ManualResetEvent); @@ -142,7 +145,7 @@ public void Range_LongRunning1() Assert.True(done); } - [Fact] + [TestMethod] [MethodImpl(MethodImplOptions.NoOptimization)] public void Range_LongRunning2() { @@ -168,7 +171,7 @@ public void Range_LongRunning2() Assert.True(true); } - [Fact] + [TestMethod] public void Range_LongRunning_Empty() { var start = default(ManualResetEvent); @@ -183,7 +186,7 @@ public void Range_LongRunning_Empty() Assert.True(lst.SequenceEqual(Enumerable.Range(5, 0))); } - [Fact] + [TestMethod] public void Range_LongRunning_Regular() { var start = default(ManualResetEvent); @@ -198,7 +201,7 @@ public void Range_LongRunning_Regular() Assert.True(lst.SequenceEqual(Enumerable.Range(5, 17))); } - [Fact] + [TestMethod] public void Range_LongRunning_Boundaries() { var start = default(ManualResetEvent); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RefCountTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RefCountTest.cs index 07155c3d77..88b3991654 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RefCountTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RefCountTest.cs @@ -10,10 +10,13 @@ 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 RefCountTest : ReactiveTest { private sealed class DematerializingConnectableObservable : IConnectableObservable @@ -36,7 +39,7 @@ public IDisposable Connect() } } - [Fact] + [TestMethod] public void RefCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.RefCount(null)); @@ -46,7 +49,7 @@ public void RefCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.RefCount(Observable.Never().Publish(), -2)); } - [Fact] + [TestMethod] public void RefCount_ConnectsOnFirst() { var scheduler = new TestScheduler(); @@ -78,7 +81,7 @@ public void RefCount_ConnectsOnFirst() Assert.True(subject.Disposed); } - [Fact] + [TestMethod] public void RefCount_NotConnected() { var disconnected = false; @@ -122,7 +125,7 @@ public void RefCount_NotConnected() Assert.True(disconnected); } - [Fact] + [TestMethod] public void RefCount_OnError() { var ex = new Exception(); @@ -134,7 +137,7 @@ public void RefCount_OnError() res.Subscribe(_ => { Assert.True(false); }, ex_ => { Assert.Same(ex, ex_); }, () => { Assert.True(false); }); } - [Fact] + [TestMethod] public void RefCount_Publish() { var scheduler = new TestScheduler(); @@ -204,7 +207,7 @@ public void RefCount_Publish() ); } - [Fact] + [TestMethod] public void RefCount_can_connect_again_if_previous_subscription_terminated_synchronously() { var seen = 0; @@ -242,7 +245,7 @@ public void RefCount_can_connect_again_if_previous_subscription_terminated_synch } } - [Fact] + [TestMethod] public void LazyRefCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.RefCount(null, TimeSpan.FromSeconds(2))); @@ -257,7 +260,7 @@ public void LazyRefCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.RefCount(Observable.Never().Publish(), -1, TimeSpan.FromSeconds(2), Scheduler.Default)); } - [Fact] + [TestMethod] public void LazyRefCount_ConnectsOnFirst() { var scheduler = new TestScheduler(); @@ -289,7 +292,7 @@ public void LazyRefCount_ConnectsOnFirst() Assert.True(subject.Disposed); } - [Fact] + [TestMethod] public void LazyRefCount_NotConnected() { var scheduler = new TestScheduler(); @@ -341,7 +344,7 @@ public void LazyRefCount_NotConnected() Assert.True(disconnected); } - [Fact] + [TestMethod] public void LazyRefCount_OnError() { var ex = new Exception(); @@ -353,7 +356,7 @@ public void LazyRefCount_OnError() res.Subscribe(_ => throw new Exception(), ex_ => { Assert.Same(ex, ex_); }, () => throw new Exception()); } - [Fact] + [TestMethod] public void LazyRefCount_Publish() { var scheduler = new TestScheduler(); @@ -426,7 +429,7 @@ public void LazyRefCount_Publish() ); } - [Fact] + [TestMethod] public void RefCount_source_already_completed_synchronously() { var subscribed = 0; @@ -451,7 +454,7 @@ public void RefCount_source_already_completed_synchronously() Assert.Equal(1, unsubscribed); } - [Fact] + [TestMethod] public void RefCount_minObservers_not_connected_Eager() { int connected = 0; @@ -470,7 +473,7 @@ public void RefCount_minObservers_not_connected_Eager() Assert.Equal(0, connected); } - [Fact] + [TestMethod] public void RefCount_minObservers_connected_Eager() { var connected = 0; @@ -501,7 +504,7 @@ public void RefCount_minObservers_connected_Eager() Assert.Equal(expected, list2); } - [Fact] + [TestMethod] public void RefCount_minObservers_not_connected_Lazy() { int connected = 0; @@ -520,7 +523,7 @@ public void RefCount_minObservers_not_connected_Lazy() Assert.Equal(0, connected); } - [Fact] + [TestMethod] public void RefCount_minObservers_connected_Lazy() { var connected = 0; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatTest.cs index 69ddfae98b..2ae6da5ea5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatTest.cs @@ -11,14 +11,17 @@ 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 RepeatTest : ReactiveTest { - [Fact] + [TestMethod] public void Repeat_Value_Count_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(1, 0, default)); @@ -26,7 +29,7 @@ public void Repeat_Value_Count_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Repeat(1, 1, DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Value_Count_Zero() { var scheduler = new TestScheduler(); @@ -46,7 +49,7 @@ public void Repeat_Value_Count_Zero() #endif } - [Fact] + [TestMethod] public void Repeat_Value_Count_One() { var scheduler = new TestScheduler(); @@ -61,7 +64,7 @@ public void Repeat_Value_Count_One() ); } - [Fact] + [TestMethod] public void Repeat_Value_Count_Ten() { var scheduler = new TestScheduler(); @@ -85,7 +88,7 @@ public void Repeat_Value_Count_Ten() ); } - [Fact] + [TestMethod] public void Repeat_Value_Count_Dispose() { var scheduler = new TestScheduler(); @@ -105,27 +108,27 @@ public void Repeat_Value_Count_Dispose() ); } - [Fact] + [TestMethod] public void Repeat_Value_Count_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(1, -1)); ReactiveAssert.Throws(() => Observable.Repeat(1, 1).Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Value_Count_Default() { Observable.Repeat(42, 10).AssertEqual(Observable.Repeat(42, 10, DefaultScheduler.Instance)); } - [Fact] + [TestMethod] public void Repeat_Value_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(1, null)); ReactiveAssert.Throws(() => Observable.Repeat(DummyScheduler.Instance, 1).Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Value() { var scheduler = new TestScheduler(); @@ -145,20 +148,20 @@ public void Repeat_Value() ); } - [Fact] + [TestMethod] public void Repeat_Value_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(1).Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Value_Default() { Observable.Repeat(42).Take(100).AssertEqual(Observable.Repeat(42, DefaultScheduler.Instance).Take(100)); } #if !NO_PERF - [Fact] + [TestMethod] public void Repeat_Count_LongRunning1() { var start = default(ManualResetEvent); @@ -177,7 +180,7 @@ public void Repeat_Count_LongRunning1() Assert.True(done); } - [Fact] + [TestMethod] [MethodImpl(MethodImplOptions.NoOptimization)] public void Repeat_Count_LongRunning2() { @@ -203,7 +206,7 @@ public void Repeat_Count_LongRunning2() Assert.True(true); } - [Fact] + [TestMethod] [MethodImpl(MethodImplOptions.NoOptimization)] public void Repeat_Inf_LongRunning() { @@ -230,14 +233,14 @@ public void Repeat_Inf_LongRunning() } #endif - [Fact] + [TestMethod] public void Repeat_Observable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(null)); ReactiveAssert.Throws(() => DummyObservable.Instance.Repeat().Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Observable_Basic() { var scheduler = new TestScheduler(); @@ -273,7 +276,7 @@ public void Repeat_Observable_Basic() ); } - [Fact] + [TestMethod] public void Repeat_Observable_Infinite() { var scheduler = new TestScheduler(); @@ -299,7 +302,7 @@ public void Repeat_Observable_Infinite() ); } - [Fact] + [TestMethod] public void Repeat_Observable_Error() { var scheduler = new TestScheduler(); @@ -329,7 +332,7 @@ public void Repeat_Observable_Error() ); } - [Fact] + [TestMethod] public void Repeat_Observable_Throws() { var scheduler1 = new TestScheduler(); @@ -363,14 +366,14 @@ public void Repeat_Observable_Throws() ReactiveAssert.Throws(() => xss.Subscribe()); } - [Fact] + [TestMethod] public void Repeat_Observable_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(null)); ReactiveAssert.Throws(() => DummyObservable.Instance.Repeat().Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(null, 0)); @@ -378,7 +381,7 @@ public void Repeat_Observable_RepeatCount_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Repeat(0).Subscribe(null)); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_Basic() { var scheduler = new TestScheduler(); @@ -414,7 +417,7 @@ public void Repeat_Observable_RepeatCount_Basic() ); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_Dispose() { var scheduler = new TestScheduler(); @@ -444,7 +447,7 @@ public void Repeat_Observable_RepeatCount_Dispose() ); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_Infinite() { var scheduler = new TestScheduler(); @@ -470,7 +473,7 @@ public void Repeat_Observable_RepeatCount_Infinite() ); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_Error() { var scheduler = new TestScheduler(); @@ -500,7 +503,7 @@ public void Repeat_Observable_RepeatCount_Error() ); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_Throws() { var scheduler1 = new TestScheduler(); @@ -534,7 +537,7 @@ public void Repeat_Observable_RepeatCount_Throws() ReactiveAssert.Throws(() => xss.Subscribe()); } - [Fact] + [TestMethod] public void Repeat_Observable_RepeatCount_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Repeat(default(IObservable), 0)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatWhenTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatWhenTest.cs index dd16167e56..670119433d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatWhenTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RepeatWhenTest.cs @@ -9,14 +9,17 @@ 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 class RepeatWhenTest : ReactiveTest { - [Fact] + [TestMethod] public void RepeatWhen_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.RepeatWhen(null, v => v)); @@ -24,7 +27,7 @@ public void RepeatWhen_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.RepeatWhen(v => v).Subscribe(null)); } - [Fact] + [TestMethod] public void RepeatWhen_Handler_Crash() { var scheduler = new TestScheduler(); @@ -47,7 +50,7 @@ public void RepeatWhen_Handler_Crash() ); } - [Fact] + [TestMethod] public void RepeatWhen_Handler_Error() { var scheduler = new TestScheduler(); @@ -71,7 +74,7 @@ public void RepeatWhen_Handler_Error() ); } - [Fact] + [TestMethod] public void RepeatWhen_Handler_Completed() { var scheduler = new TestScheduler(); @@ -95,7 +98,7 @@ public void RepeatWhen_Handler_Completed() ); } - [Fact] + [TestMethod] public void RepeatWhen_Disposed() { var main = new Subject(); @@ -112,7 +115,7 @@ public void RepeatWhen_Disposed() Assert.False(inner.HasObservers); } - [Fact] + [TestMethod] public void RepeatWhen_Handler_Completed_Disposes_Main() { var main = new Subject(); @@ -140,7 +143,7 @@ public void RepeatWhen_Handler_Completed_Disposes_Main() Assert.Equal(1, end); } - [Fact] + [TestMethod] public void RepeatWhen_Handler_Error_Disposes_Main() { var main = new Subject(); @@ -168,7 +171,7 @@ public void RepeatWhen_Handler_Error_Disposes_Main() Assert.Equal(0, end); } - [Fact] + [TestMethod] public void RepeatWhen_Basic() { var scheduler = new TestScheduler(); @@ -204,7 +207,7 @@ public void RepeatWhen_Basic() ); } - [Fact] + [TestMethod] public void RepeatWhen_Infinite() { var scheduler = new TestScheduler(); @@ -230,7 +233,7 @@ public void RepeatWhen_Infinite() ); } - [Fact] + [TestMethod] public void RepeatWhen_Error() { var scheduler = new TestScheduler(); @@ -260,7 +263,7 @@ public void RepeatWhen_Error() ); } - [Fact] + [TestMethod] public void RepeatWhen_Throws() { var scheduler1 = new TestScheduler(); @@ -294,7 +297,7 @@ public void RepeatWhen_Throws() ReactiveAssert.Throws(() => xss.Subscribe()); } - [Fact] + [TestMethod] public void RepeatWhen_RepeatCount_Basic() { var scheduler = new TestScheduler(); @@ -334,7 +337,7 @@ public void RepeatWhen_RepeatCount_Basic() ); } - [Fact] + [TestMethod] public void RepeatWhen_RepeatCount_Dispose() { var scheduler = new TestScheduler(); @@ -368,7 +371,7 @@ public void RepeatWhen_RepeatCount_Dispose() ); } - [Fact] + [TestMethod] public void RepeatWhen_RepeatCount_Infinite() { var scheduler = new TestScheduler(); @@ -398,7 +401,7 @@ public void RepeatWhen_RepeatCount_Infinite() ); } - [Fact] + [TestMethod] public void RepeatWhen_RepeatCount_Error() { var scheduler = new TestScheduler(); @@ -432,7 +435,7 @@ public void RepeatWhen_RepeatCount_Error() ); } - [Fact] + [TestMethod] public void RepeatWhen_RepeatCount_Throws() { var scheduler1 = new TestScheduler(); @@ -482,7 +485,7 @@ public void RepeatWhen_RepeatCount_Throws() ReactiveAssert.Throws(() => xss.Subscribe()); } - [Fact] + [TestMethod] public void RepeatWhen_Observable_Repeat_Delayed() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReplayTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReplayTest.cs index 662145769a..c349e71b6e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReplayTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReplayTest.cs @@ -9,14 +9,17 @@ 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 class ReplayTest : ReactiveTest { - [Fact] + [TestMethod] public void Replay_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -72,7 +75,7 @@ public void Replay_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Replay(someObservable, x => x, 1, TimeSpan.FromSeconds(1), null)); } - [Fact] + [TestMethod] public void ReplayCount_Basic() { var scheduler = new TestScheduler(); @@ -128,7 +131,7 @@ public void ReplayCount_Basic() ); } - [Fact] + [TestMethod] public void ReplayCount_Error() { var scheduler = new TestScheduler(); @@ -184,7 +187,7 @@ public void ReplayCount_Error() ); } - [Fact] + [TestMethod] public void ReplayCount_Complete() { var scheduler = new TestScheduler(); @@ -238,7 +241,7 @@ public void ReplayCount_Complete() ); } - [Fact] + [TestMethod] public void ReplayCount_Dispose() { var scheduler = new TestScheduler(); @@ -293,7 +296,7 @@ public void ReplayCount_Dispose() ); } - [Fact] + [TestMethod] public void ReplayCount_MultipleConnections() { var xs = Observable.Never(); @@ -314,7 +317,7 @@ public void ReplayCount_MultipleConnections() connection3.Dispose(); } - [Fact] + [TestMethod] public void ReplayCountLambda_Zip_Complete() { var scheduler = new TestScheduler(); @@ -376,7 +379,7 @@ public void ReplayCountLambda_Zip_Complete() ); } - [Fact] + [TestMethod] public void ReplayCountLambda_Zip_Error() { var scheduler = new TestScheduler(); @@ -434,7 +437,7 @@ public void ReplayCountLambda_Zip_Error() ); } - [Fact] + [TestMethod] public void ReplayCountLambda_Zip_Dispose() { var scheduler = new TestScheduler(); @@ -485,7 +488,7 @@ public void ReplayCountLambda_Zip_Dispose() ); } - [Fact] + [TestMethod] public void ReplayTime_Basic() { var scheduler = new TestScheduler(); @@ -542,7 +545,7 @@ public void ReplayTime_Basic() ); } - [Fact] + [TestMethod] public void ReplayTime_Error() { var scheduler = new TestScheduler(); @@ -596,7 +599,7 @@ public void ReplayTime_Error() ); } - [Fact] + [TestMethod] public void ReplayTime_Complete() { var scheduler = new TestScheduler(); @@ -649,7 +652,7 @@ public void ReplayTime_Complete() ); } - [Fact] + [TestMethod] public void ReplayTime_Dispose() { var scheduler = new TestScheduler(); @@ -704,7 +707,7 @@ public void ReplayTime_Dispose() ); } - [Fact] + [TestMethod] public void ReplayTime_MultipleConnections() { var xs = Observable.Never(); @@ -725,7 +728,7 @@ public void ReplayTime_MultipleConnections() connection3.Dispose(); } - [Fact] + [TestMethod] public void ReplayTimeLambda_Zip_Complete() { var scheduler = new TestScheduler(); @@ -784,7 +787,7 @@ public void ReplayTimeLambda_Zip_Complete() ); } - [Fact] + [TestMethod] public void ReplayTimeLambda_Zip_Error() { var scheduler = new TestScheduler(); @@ -841,7 +844,7 @@ public void ReplayTimeLambda_Zip_Error() ); } - [Fact] + [TestMethod] public void ReplayTimeLambda_Zip_Dispose() { var scheduler = new TestScheduler(); @@ -892,7 +895,7 @@ public void ReplayTimeLambda_Zip_Dispose() ); } - [Fact] + [TestMethod] public void Replay_Default1() { var s = new Subject(); @@ -909,7 +912,7 @@ public void Replay_Default1() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void Replay_Default2() { var s = new Subject(); @@ -926,7 +929,7 @@ public void Replay_Default2() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void Replay_Default3() { var s = new Subject(); @@ -943,7 +946,7 @@ public void Replay_Default3() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void Replay_Default4() { var s = new Subject(); @@ -960,7 +963,7 @@ public void Replay_Default4() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void ReplayLambda_Default1() { var xs = Observable.Range(1, 10).Replay(_xs => _xs, 100, DefaultScheduler.Instance); @@ -969,7 +972,7 @@ public void ReplayLambda_Default1() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void ReplayLambda_Default2() { var xs = Observable.Range(1, 10).Replay(_xs => _xs, TimeSpan.FromHours(1), DefaultScheduler.Instance); @@ -978,7 +981,7 @@ public void ReplayLambda_Default2() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void ReplayLambda_Default3() { var xs = Observable.Range(1, 10).Replay(_xs => _xs, 100, TimeSpan.FromHours(1), DefaultScheduler.Instance); @@ -987,7 +990,7 @@ public void ReplayLambda_Default3() xs.AssertEqual(ys); } - [Fact] + [TestMethod] public void ReplayLambda_Default4() { var xs = Observable.Range(1, 10).Replay(_xs => _xs, DefaultScheduler.Instance); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryTest.cs index 143bea656c..8579a9f6ab 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryTest.cs @@ -7,21 +7,22 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class RetryTest : ReactiveTest { - [Fact] + [TestMethod] public void Retry_Observable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Retry(null)); ReactiveAssert.Throws(() => DummyObservable.Instance.Retry().Subscribe(null)); } - [Fact] + [TestMethod] public void Retry_Observable_Basic() { var scheduler = new TestScheduler(); @@ -49,7 +50,7 @@ public void Retry_Observable_Basic() ); } - [Fact] + [TestMethod] public void Retry_Observable_Infinite() { var scheduler = new TestScheduler(); @@ -75,7 +76,7 @@ public void Retry_Observable_Infinite() ); } - [Fact] + [TestMethod] public void Retry_Observable_Error() { var scheduler = new TestScheduler(); @@ -114,7 +115,7 @@ public void Retry_Observable_Error() ); } - [Fact] + [TestMethod] public void Retry_Observable_Throws1() { var scheduler1 = new TestScheduler(); @@ -126,7 +127,7 @@ public void Retry_Observable_Throws1() ReactiveAssert.Throws(() => scheduler1.Start()); } - [Fact] + [TestMethod] public void Retry_Observable_Throws2() { var scheduler2 = new TestScheduler(); @@ -140,7 +141,7 @@ public void Retry_Observable_Throws2() scheduler2.Start(); } - [Fact] + [TestMethod] public void Retry_Observable_Throws3() { var scheduler3 = new TestScheduler(); @@ -156,7 +157,7 @@ public void Retry_Observable_Throws3() * BREAKING CHANGE v2.0 > v1.x - The code below will loop endlessly, trying to repeat the failing subscription, * whose exception is propagated through OnError starting from v2.0. * - [Fact] + [TestMethod] public void Retry_Observable_Throws4() { var xss = Observable.Create(new Func, Action>(o => { throw new InvalidOperationException(); })).Retry(); @@ -165,14 +166,14 @@ public void Retry_Observable_Throws4() } */ - [Fact] + [TestMethod] public void Retry_Observable_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Retry(null)); ReactiveAssert.Throws(() => DummyObservable.Instance.Retry().Subscribe(null)); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Retry(null, 0)); @@ -180,7 +181,7 @@ public void Retry_Observable_RetryCount_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Retry(0).Subscribe(null)); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Basic() { var scheduler = new TestScheduler(); @@ -218,7 +219,7 @@ public void Retry_Observable_RetryCount_Basic() ); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Dispose() { var scheduler = new TestScheduler(); @@ -248,7 +249,7 @@ public void Retry_Observable_RetryCount_Dispose() ); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Infinite() { var scheduler = new TestScheduler(); @@ -274,7 +275,7 @@ public void Retry_Observable_RetryCount_Infinite() ); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Completed() { var scheduler = new TestScheduler(); @@ -302,7 +303,7 @@ public void Retry_Observable_RetryCount_Completed() ); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Throws() { var scheduler1 = new TestScheduler(); @@ -336,7 +337,7 @@ public void Retry_Observable_RetryCount_Throws() ReactiveAssert.Throws(() => xss.Subscribe()); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Retry(default, 0)); @@ -344,7 +345,7 @@ public void Retry_Observable_RetryCount_Default_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Retry(0).Subscribe(null)); } - [Fact] + [TestMethod] public void Retry_Observable_RetryCount_Default() { Observable.Range(1, 3).Retry(3).AssertEqual(Observable.Range(1, 3).Retry(3)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryWhenTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryWhenTest.cs index bff3cbd9f6..f373842abf 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryWhenTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RetryWhenTest.cs @@ -7,13 +7,14 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class RetryWhenTest : ReactiveTest { - [Fact] + [TestMethod] public void RetryWhen_Observable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.RetryWhen(null, v => v)); @@ -21,7 +22,7 @@ public void RetryWhen_Observable_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.RetryWhen(v => v).Subscribe(null)); } - [Fact] + [TestMethod] public void RetryWhen_Observable_Basic() { var scheduler = new TestScheduler(); @@ -49,7 +50,7 @@ public void RetryWhen_Observable_Basic() ); } - [Fact] + [TestMethod] public void RetryWhen_Observable_Handler_Completes() { var scheduler = new TestScheduler(); @@ -80,7 +81,7 @@ public void RetryWhen_Observable_Handler_Completes() } - [Fact] + [TestMethod] public void RetryWhen_Observable_Handler_Throws() { var scheduler = new TestScheduler(); @@ -96,7 +97,7 @@ public void RetryWhen_Observable_Handler_Throws() ); } - [Fact] + [TestMethod] public void RetryWhen_Observable_Handler_Errors() { var scheduler = new TestScheduler(); @@ -127,7 +128,7 @@ public void RetryWhen_Observable_Handler_Errors() ); } - [Fact] + [TestMethod] public void RetryWhen_Observable_RetryCount_Basic() { var scheduler = new TestScheduler(); @@ -177,7 +178,7 @@ public void RetryWhen_Observable_RetryCount_Basic() ); } - [Fact] + [TestMethod] public void RetryWhen_Observable_RetryCount_Delayed() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReturnTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReturnTest.cs index f8e999cdfe..b4a3f47c4d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReturnTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ReturnTest.cs @@ -8,21 +8,22 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class ReturnTest : ReactiveTest { - [Fact] + [TestMethod] public void Return_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Return(0, null)); ReactiveAssert.Throws(() => Observable.Return(0, DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Return_Basic() { var scheduler = new TestScheduler(); @@ -37,7 +38,7 @@ public void Return_Basic() ); } - [Fact] + [TestMethod] public void Return_Disposed() { var scheduler = new TestScheduler(); @@ -51,7 +52,7 @@ public void Return_Disposed() ); } - [Fact] + [TestMethod] public void Return_DisposedAfterNext() { var scheduler = new TestScheduler(); @@ -81,7 +82,7 @@ public void Return_DisposedAfterNext() ); } - [Fact] + [TestMethod] public void Return_ObserverThrows() { var scheduler1 = new TestScheduler(); @@ -101,7 +102,7 @@ public void Return_ObserverThrows() ReactiveAssert.Throws(() => scheduler2.Start()); } - [Fact] + [TestMethod] public void Return_DefaultScheduler() { Observable.Return(42).AssertEqual(Observable.Return(42, DefaultScheduler.Instance)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RunAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RunAsyncTest.cs index f6e5827ee8..5f0402966c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RunAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/RunAsyncTest.cs @@ -9,13 +9,16 @@ 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 RunAsyncTest : ReactiveTest { - [Fact] + [TestMethod] public void RunAsync_ArgumentChecking() { var ct = CancellationToken.None; @@ -24,7 +27,7 @@ public void RunAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.RunAsync(default, ct)); } - [Fact] + [TestMethod] public void RunAsync_Simple() { SynchronizationContext.SetSynchronizationContext(null); @@ -53,7 +56,7 @@ public void RunAsync_Simple() ); } - [Fact] + [TestMethod] public void RunAsync_Cancelled() { SynchronizationContext.SetSynchronizationContext(null); @@ -91,7 +94,7 @@ public void RunAsync_Cancelled() ); } - [Fact] + [TestMethod] public void RunAsync_Cancel() { SynchronizationContext.SetSynchronizationContext(null); @@ -130,7 +133,7 @@ public void RunAsync_Cancel() ); } - [Fact] + [TestMethod] public void RunAsync_Connectable() { SynchronizationContext.SetSynchronizationContext(null); @@ -165,7 +168,7 @@ public void RunAsync_Connectable() Assert.Equal(42, result); } - [Fact] + [TestMethod] public void RunAsync_Connectable_Cancelled() { SynchronizationContext.SetSynchronizationContext(null); @@ -210,7 +213,7 @@ public void RunAsync_Connectable_Cancelled() Assert.Equal(200, t); } - [Fact] + [TestMethod] public void RunAsync_Connectable_Cancel() { SynchronizationContext.SetSynchronizationContext(null); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SampleTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SampleTest.cs index 7a1f289e52..89fc385ceb 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SampleTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SampleTest.cs @@ -7,14 +7,17 @@ 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 SampleTest : ReactiveTest { - [Fact] + [TestMethod] public void Sample_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -31,7 +34,7 @@ public void Sample_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Sample(someObservable, default(IObservable))); } - [Fact] + [TestMethod] public void Sample_Regular() { var scheduler = new TestScheduler(); @@ -64,7 +67,7 @@ public void Sample_Regular() ); } - [Fact] + [TestMethod] public void Sample_Periodic_Regular() { var scheduler = new PeriodicTestScheduler(); @@ -103,7 +106,7 @@ public void Sample_Periodic_Regular() #endif } - [Fact] + [TestMethod] public void Sample_ErrorInFlight() { var scheduler = new TestScheduler(); @@ -135,7 +138,7 @@ public void Sample_ErrorInFlight() ); } - [Fact] + [TestMethod] public void Sample_Periodic_ErrorInFlight() { var scheduler = new PeriodicTestScheduler(); @@ -173,7 +176,7 @@ public void Sample_Periodic_ErrorInFlight() #endif } - [Fact] + [TestMethod] public void Sample_Empty() { var scheduler = new TestScheduler(); @@ -196,7 +199,7 @@ public void Sample_Empty() ); } - [Fact] + [TestMethod] public void Sample_Periodic_Empty() { var scheduler = new PeriodicTestScheduler(); @@ -225,7 +228,7 @@ public void Sample_Periodic_Empty() #endif } - [Fact] + [TestMethod] public void Sample_Error() { var scheduler = new TestScheduler(); @@ -250,7 +253,7 @@ public void Sample_Error() ); } - [Fact] + [TestMethod] public void Sample_Periodic_Error() { var scheduler = new PeriodicTestScheduler(); @@ -281,7 +284,7 @@ public void Sample_Periodic_Error() #endif } - [Fact] + [TestMethod] public void Sample_Never() { var scheduler = new TestScheduler(); @@ -302,7 +305,7 @@ public void Sample_Never() ); } - [Fact] + [TestMethod] public void Sample_Periodic_Never() { var scheduler = new PeriodicTestScheduler(); @@ -329,21 +332,21 @@ public void Sample_Periodic_Never() #endif } - [Fact] + [TestMethod] public void Sample_DefaultScheduler_Periodic() { var res = Observable.Return(42).Sample(TimeSpan.FromMilliseconds(1)).ToEnumerable().Single(); Assert.Equal(42, res); } - [Fact] + [TestMethod] public void Sample_DefaultScheduler_PeriodicDisabled() { var res = Observable.Return(42).Sample(TimeSpan.FromMilliseconds(1), Scheduler.Default.DisableOptimizations()).ToEnumerable().Single(); Assert.Equal(42, res); } - [Fact] + [TestMethod] public void Sample_Sampler_Simple1() { var scheduler = new TestScheduler(); @@ -386,7 +389,7 @@ public void Sample_Sampler_Simple1() ); } - [Fact] + [TestMethod] public void Sample_Sampler_Simple2() { var scheduler = new TestScheduler(); @@ -431,7 +434,7 @@ public void Sample_Sampler_Simple2() ); } - [Fact] + [TestMethod] public void Sample_Sampler_Simple3() { var scheduler = new TestScheduler(); @@ -472,7 +475,7 @@ public void Sample_Sampler_Simple3() ); } - [Fact] + [TestMethod] public void Sample_Sampler_completes_first() { var scheduler = new TestScheduler(); @@ -513,7 +516,7 @@ public void Sample_Sampler_completes_first() ); } - [Fact] + [TestMethod] public void Sample_Sampler_SourceThrows() { var ex = new Exception(); @@ -558,7 +561,7 @@ public void Sample_Sampler_SourceThrows() } #if !NO_PERF // BREAKING CHANGE v2 > v1.x - behavior when sampler throws - [Fact] + [TestMethod] public void Sample_Sampler_SamplerThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ScanTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ScanTest.cs index 4f1dece7cb..0468928672 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ScanTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ScanTest.cs @@ -5,14 +5,15 @@ using System; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class ScanTest : ReactiveTest { - [Fact] + [TestMethod] public void Scan_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -23,7 +24,7 @@ public void Scan_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Scan(someObservable, 0, null)); } - [Fact] + [TestMethod] public void Scan_Seed_Never() { var scheduler = new TestScheduler(); @@ -43,7 +44,7 @@ public void Scan_Seed_Never() ); } - [Fact] + [TestMethod] public void Scan_Seed_Empty() { var scheduler = new TestScheduler(); @@ -67,7 +68,7 @@ public void Scan_Seed_Empty() ); } - [Fact] + [TestMethod] public void Scan_Seed_Return() { var scheduler = new TestScheduler(); @@ -93,7 +94,7 @@ public void Scan_Seed_Return() ); } - [Fact] + [TestMethod] public void Scan_Seed_Throw() { var scheduler = new TestScheduler(); @@ -118,7 +119,7 @@ public void Scan_Seed_Throw() ); } - [Fact] + [TestMethod] public void Scan_Seed_SomeData() { var scheduler = new TestScheduler(); @@ -150,7 +151,7 @@ public void Scan_Seed_SomeData() ); } - [Fact] + [TestMethod] public void Scan_Seed_AccumulatorThrows() { var scheduler = new TestScheduler(); @@ -181,7 +182,7 @@ public void Scan_Seed_AccumulatorThrows() ); } - [Fact] + [TestMethod] public void Scan_NoSeed_Never() { var scheduler = new TestScheduler(); @@ -200,7 +201,7 @@ public void Scan_NoSeed_Never() ); } - [Fact] + [TestMethod] public void Scan_NoSeed_Empty() { var scheduler = new TestScheduler(); @@ -223,7 +224,7 @@ public void Scan_NoSeed_Empty() ); } - [Fact] + [TestMethod] public void Scan_NoSeed_Return() { var scheduler = new TestScheduler(); @@ -248,7 +249,7 @@ public void Scan_NoSeed_Return() ); } - [Fact] + [TestMethod] public void Scan_NoSeed_Throw() { var scheduler = new TestScheduler(); @@ -272,7 +273,7 @@ public void Scan_NoSeed_Throw() ); } - [Fact] + [TestMethod] public void Scan_NoSeed_SomeData() { var scheduler = new TestScheduler(); @@ -303,7 +304,7 @@ public void Scan_NoSeed_SomeData() ); } - [Fact] + [TestMethod] public void Scan_NoSeed_AccumulatorThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectManyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectManyTest.cs index 483da2e307..e35b2b4a3a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectManyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectManyTest.cs @@ -11,14 +11,17 @@ 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 SelectManyTest : ReactiveTest { - [Fact] + [TestMethod] public void SelectMany_Then_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyObservable.Instance)); @@ -26,7 +29,7 @@ public void SelectMany_Then_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyObservable.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectMany_Then_Complete_Complete() { var scheduler = new TestScheduler(); @@ -83,7 +86,7 @@ public void SelectMany_Then_Complete_Complete() ); } - [Fact] + [TestMethod] public void SelectMany_Then_Complete_Complete_2() { var scheduler = new TestScheduler(); @@ -140,7 +143,7 @@ public void SelectMany_Then_Complete_Complete_2() ); } - [Fact] + [TestMethod] public void SelectMany_Then_Never_Complete() { var scheduler = new TestScheduler(); @@ -204,7 +207,7 @@ public void SelectMany_Then_Never_Complete() ); } - [Fact] + [TestMethod] public void SelectMany_Then_Complete_Never() { var scheduler = new TestScheduler(); @@ -259,7 +262,7 @@ public void SelectMany_Then_Complete_Never() ); } - [Fact] + [TestMethod] public void SelectMany_Then_Complete_Error() { var scheduler = new TestScheduler(); @@ -310,7 +313,7 @@ public void SelectMany_Then_Complete_Error() ); } - [Fact] + [TestMethod] public void SelectMany_Then_Error_Complete() { var scheduler = new TestScheduler(); @@ -365,7 +368,7 @@ public void SelectMany_Then_Error_Complete() ); } - [Fact] + [TestMethod] public void SelectMany_Then_Error_Error() { var scheduler = new TestScheduler(); @@ -413,7 +416,7 @@ public void SelectMany_Then_Error_Error() ); } - [Fact] + [TestMethod] public void SelectMany_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance)); @@ -421,7 +424,7 @@ public void SelectMany_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyFunc>.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectMany_Complete() { var scheduler = new TestScheduler(); @@ -499,7 +502,7 @@ public void SelectMany_Complete() Subscribe(850, 950)); } - [Fact] + [TestMethod] public void SelectMany_Complete_InnerNotComplete() { var scheduler = new TestScheduler(); @@ -575,7 +578,7 @@ public void SelectMany_Complete_InnerNotComplete() Subscribe(850, 950)); } - [Fact] + [TestMethod] public void SelectMany_Complete_OuterNotComplete() { var scheduler = new TestScheduler(); @@ -651,7 +654,7 @@ public void SelectMany_Complete_OuterNotComplete() Subscribe(850, 950)); } - [Fact] + [TestMethod] public void SelectMany_Error_Outer() { var scheduler = new TestScheduler(); @@ -729,7 +732,7 @@ public void SelectMany_Error_Outer() Subscribe(850, 900)); } - [Fact] + [TestMethod] public void SelectMany_Error_Inner() { var scheduler = new TestScheduler(); @@ -805,7 +808,7 @@ public void SelectMany_Error_Inner() ); } - [Fact] + [TestMethod] public void SelectMany_Dispose() { var scheduler = new TestScheduler(); @@ -878,7 +881,7 @@ public void SelectMany_Dispose() ); } - [Fact] + [TestMethod] public void SelectMany_Throw() { var scheduler = new TestScheduler(); @@ -961,7 +964,7 @@ public void SelectMany_Throw() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectMany_UseFunction() { var scheduler = new TestScheduler(); @@ -1000,7 +1003,7 @@ public void SelectMany_UseFunction() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance)); @@ -1008,7 +1011,7 @@ public void SelectManyWithIndex_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyFunc>.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Index() { var scheduler = new TestScheduler(); @@ -1040,7 +1043,7 @@ public void SelectManyWithIndex_Index() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Complete() { var scheduler = new TestScheduler(); @@ -1118,7 +1121,7 @@ public void SelectManyWithIndex_Complete() Subscribe(850, 950)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Complete_InnerNotComplete() { var scheduler = new TestScheduler(); @@ -1194,7 +1197,7 @@ public void SelectManyWithIndex_Complete_InnerNotComplete() Subscribe(850, 950)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Complete_OuterNotComplete() { var scheduler = new TestScheduler(); @@ -1270,7 +1273,7 @@ public void SelectManyWithIndex_Complete_OuterNotComplete() Subscribe(850, 950)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Error_Outer() { var scheduler = new TestScheduler(); @@ -1348,7 +1351,7 @@ public void SelectManyWithIndex_Error_Outer() Subscribe(850, 900)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Error_Inner() { var scheduler = new TestScheduler(); @@ -1424,7 +1427,7 @@ public void SelectManyWithIndex_Error_Inner() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Dispose() { var scheduler = new TestScheduler(); @@ -1497,7 +1500,7 @@ public void SelectManyWithIndex_Dispose() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Throw() { var scheduler = new TestScheduler(); @@ -1580,7 +1583,7 @@ public void SelectManyWithIndex_Throw() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectManyWithIndex_UseFunction() { var scheduler = new TestScheduler(); @@ -1619,7 +1622,7 @@ public void SelectManyWithIndex_UseFunction() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance)); @@ -1631,7 +1634,7 @@ public void SelectMany_Enumerable_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyFunc>.Instance, (Func)null)); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_Complete() { var scheduler = new TestScheduler(); @@ -1693,7 +1696,7 @@ public void SelectMany_Enumerable_Complete() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_Complete_ResultSelector() { var scheduler = new TestScheduler(); @@ -1730,7 +1733,7 @@ public void SelectMany_Enumerable_Complete_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_Error() { var scheduler = new TestScheduler(); @@ -1769,7 +1772,7 @@ public void SelectMany_Enumerable_Error() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_Error_ResultSelector() { var scheduler = new TestScheduler(); @@ -1808,7 +1811,7 @@ public void SelectMany_Enumerable_Error_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_Dispose() { var scheduler = new TestScheduler(); @@ -1840,7 +1843,7 @@ public void SelectMany_Enumerable_Dispose() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_Dispose_ResultSelector() { var scheduler = new TestScheduler(); @@ -1872,7 +1875,7 @@ public void SelectMany_Enumerable_Dispose_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_SelectorThrows() { var scheduler = new TestScheduler(); @@ -1918,7 +1921,7 @@ public void SelectMany_Enumerable_SelectorThrows() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_ResultSelectorThrows() { var scheduler = new TestScheduler(); @@ -1984,7 +1987,7 @@ public void SelectMany_Enumerable_ResultSelectorThrows() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_ResultSelector_GetEnumeratorThrows() { var scheduler = new TestScheduler(); @@ -2012,7 +2015,7 @@ public void SelectMany_Enumerable_ResultSelector_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_SelectorThrows_ResultSelector() { var scheduler = new TestScheduler(); @@ -2120,7 +2123,7 @@ public void Reset() } } - [Fact] + [TestMethod] public void SelectMany_Enumerable_CurrentThrows() { var scheduler = new TestScheduler(); @@ -2148,7 +2151,7 @@ public void SelectMany_Enumerable_CurrentThrows() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_CurrentThrows_ResultSelector() { var scheduler = new TestScheduler(); @@ -2235,7 +2238,7 @@ public void Reset() } } - [Fact] + [TestMethod] public void SelectMany_Enumerable_GetEnumeratorThrows() { var scheduler = new TestScheduler(); @@ -2263,7 +2266,7 @@ public void SelectMany_Enumerable_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_MoveNextThrows() { var scheduler = new TestScheduler(); @@ -2291,7 +2294,7 @@ public void SelectMany_Enumerable_MoveNextThrows() ); } - [Fact] + [TestMethod] public void SelectMany_Enumerable_MoveNextThrows_ResultSelector() { var scheduler = new TestScheduler(); @@ -2319,7 +2322,7 @@ public void SelectMany_Enumerable_MoveNextThrows_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance)); @@ -2331,7 +2334,7 @@ public void SelectManyWithIndex_Enumerable_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyFunc>.Instance, (Func)null)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Index() { var scheduler = new TestScheduler(); @@ -2363,7 +2366,7 @@ public void SelectManyWithIndex_Enumerable_Index() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_ResultSelector_Index() { var scheduler = new TestScheduler(); @@ -2401,7 +2404,7 @@ public void SelectManyWithIndex_Enumerable_ResultSelector_Index() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Complete() { var scheduler = new TestScheduler(); @@ -2463,7 +2466,7 @@ public void SelectManyWithIndex_Enumerable_Complete() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Complete_ResultSelector() { var scheduler = new TestScheduler(); @@ -2500,7 +2503,7 @@ public void SelectManyWithIndex_Enumerable_Complete_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Error() { var scheduler = new TestScheduler(); @@ -2539,7 +2542,7 @@ public void SelectManyWithIndex_Enumerable_Error() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Error_ResultSelector() { var scheduler = new TestScheduler(); @@ -2578,7 +2581,7 @@ public void SelectManyWithIndex_Enumerable_Error_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Dispose() { var scheduler = new TestScheduler(); @@ -2610,7 +2613,7 @@ public void SelectManyWithIndex_Enumerable_Dispose() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_Dispose_ResultSelector() { var scheduler = new TestScheduler(); @@ -2642,7 +2645,7 @@ public void SelectManyWithIndex_Enumerable_Dispose_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_SelectorThrows() { var scheduler = new TestScheduler(); @@ -2688,7 +2691,7 @@ public void SelectManyWithIndex_Enumerable_SelectorThrows() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_ResultSelectorThrows() { var scheduler = new TestScheduler(); @@ -2754,7 +2757,7 @@ public void SelectManyWithIndex_Enumerable_ResultSelectorThrows() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_ResultSelector_GetEnumeratorThrows() { var scheduler = new TestScheduler(); @@ -2782,7 +2785,7 @@ public void SelectManyWithIndex_Enumerable_ResultSelector_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_SelectorThrows_ResultSelector() { var scheduler = new TestScheduler(); @@ -2831,7 +2834,7 @@ public void SelectManyWithIndex_Enumerable_SelectorThrows_ResultSelector() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_CurrentThrows() { var scheduler = new TestScheduler(); @@ -2859,7 +2862,7 @@ public void SelectManyWithIndex_Enumerable_CurrentThrows() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_CurrentThrows_ResultSelector() { var scheduler = new TestScheduler(); @@ -2887,7 +2890,7 @@ public void SelectManyWithIndex_Enumerable_CurrentThrows_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_GetEnumeratorThrows() { var scheduler = new TestScheduler(); @@ -2915,7 +2918,7 @@ public void SelectManyWithIndex_Enumerable_GetEnumeratorThrows() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_MoveNextThrows() { var scheduler = new TestScheduler(); @@ -2943,7 +2946,7 @@ public void SelectManyWithIndex_Enumerable_MoveNextThrows() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Enumerable_MoveNextThrows_ResultSelector() { var scheduler = new TestScheduler(); @@ -2971,7 +2974,7 @@ public void SelectManyWithIndex_Enumerable_MoveNextThrows_ResultSelector() ); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance, DummyFunc.Instance)); @@ -2994,7 +2997,7 @@ public void SelectMany_QueryOperator_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany((Func>)null)); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_CompleteOuterFirst() { var scheduler = new TestScheduler(); @@ -3036,7 +3039,7 @@ from y in Observable.Interval(TimeSpan.FromTicks(1), scheduler).Take(x) ); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_CompleteInnerFirst() { var scheduler = new TestScheduler(); @@ -3078,7 +3081,7 @@ from y in Observable.Interval(TimeSpan.FromTicks(1), scheduler).Take(x) ); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_ErrorOuter() { var scheduler = new TestScheduler(); @@ -3114,7 +3117,7 @@ from y in Observable.Interval(TimeSpan.FromTicks(1), scheduler).Take(x) ); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_ErrorInner() { var scheduler = new TestScheduler(); @@ -3148,7 +3151,7 @@ from x in xs ); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_Dispose() { var scheduler = new TestScheduler(); @@ -3185,7 +3188,7 @@ private static T Throw(Exception ex) } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_ThrowSelector() { var scheduler = new TestScheduler(); @@ -3215,7 +3218,7 @@ from y in Throw>(ex) ); } - [Fact] + [TestMethod] public void SelectMany_QueryOperator_ThrowResult() { var scheduler = new TestScheduler(); @@ -3245,7 +3248,7 @@ select Throw(ex) ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance, DummyFunc.Instance)); @@ -3254,7 +3257,7 @@ public void SelectManyWithIndex_QueryOperator_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyFunc>.Instance, DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_Index() { var scheduler = new TestScheduler(); @@ -3292,7 +3295,7 @@ public void SelectManyWithIndex_QueryOperator_Index() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_CompleteOuterFirst() { var scheduler = new TestScheduler(); @@ -3332,7 +3335,7 @@ public void SelectManyWithIndex_QueryOperator_CompleteOuterFirst() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_CompleteInnerFirst() { var scheduler = new TestScheduler(); @@ -3372,7 +3375,7 @@ public void SelectManyWithIndex_QueryOperator_CompleteInnerFirst() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_ErrorOuter() { var scheduler = new TestScheduler(); @@ -3406,7 +3409,7 @@ public void SelectManyWithIndex_QueryOperator_ErrorOuter() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_ErrorInner() { var scheduler = new TestScheduler(); @@ -3441,7 +3444,7 @@ public void SelectManyWithIndex_QueryOperator_ErrorInner() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_Dispose() { var scheduler = new TestScheduler(); @@ -3470,7 +3473,7 @@ public void SelectManyWithIndex_QueryOperator_Dispose() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_ThrowSelector() { var scheduler = new TestScheduler(); @@ -3498,7 +3501,7 @@ public void SelectManyWithIndex_QueryOperator_ThrowSelector() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_QueryOperator_ThrowResult() { var scheduler = new TestScheduler(); @@ -3527,7 +3530,7 @@ public void SelectManyWithIndex_QueryOperator_ThrowResult() } - [Fact] + [TestMethod] public void SelectMany_Triple_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SelectMany(null, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc>.Instance)); @@ -3537,7 +3540,7 @@ public void SelectMany_Triple_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SelectMany(DummyObservable.Instance, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc>.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectMany_Triple_Identity() { var scheduler = new TestScheduler(); @@ -3573,7 +3576,7 @@ public void SelectMany_Triple_Identity() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_InnersWithTiming1() { var scheduler = new TestScheduler(); @@ -3652,7 +3655,7 @@ public void SelectMany_Triple_InnersWithTiming1() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_InnersWithTiming2() { var scheduler = new TestScheduler(); @@ -3731,7 +3734,7 @@ public void SelectMany_Triple_InnersWithTiming2() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_InnersWithTiming3() { var scheduler = new TestScheduler(); @@ -3810,7 +3813,7 @@ public void SelectMany_Triple_InnersWithTiming3() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_Error_Identity() { var scheduler = new TestScheduler(); @@ -3848,7 +3851,7 @@ public void SelectMany_Triple_Error_Identity() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_SelectMany() { var scheduler = new TestScheduler(); @@ -3890,7 +3893,7 @@ public void SelectMany_Triple_SelectMany() } - [Fact] + [TestMethod] public void SelectMany_Triple_Concat() { var scheduler = new TestScheduler(); @@ -3929,7 +3932,7 @@ public void SelectMany_Triple_Concat() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_Catch() { var scheduler = new TestScheduler(); @@ -3965,7 +3968,7 @@ public void SelectMany_Triple_Catch() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_Error_Catch() { var scheduler = new TestScheduler(); @@ -4004,7 +4007,7 @@ public void SelectMany_Triple_Error_Catch() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_All() { var scheduler = new TestScheduler(); @@ -4047,7 +4050,7 @@ public void SelectMany_Triple_All() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_Error_All() { var scheduler = new TestScheduler(); @@ -4090,7 +4093,7 @@ public void SelectMany_Triple_Error_All() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_All_Dispose() { var scheduler = new TestScheduler(); @@ -4130,7 +4133,7 @@ public void SelectMany_Triple_All_Dispose() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_All_Dispose_Before_First() { var scheduler = new TestScheduler(); @@ -4163,7 +4166,7 @@ public void SelectMany_Triple_All_Dispose_Before_First() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_OnNextThrow() { var scheduler = new TestScheduler(); @@ -4196,7 +4199,7 @@ public void SelectMany_Triple_OnNextThrow() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_OnErrorThrow() { var scheduler = new TestScheduler(); @@ -4233,7 +4236,7 @@ public void SelectMany_Triple_OnErrorThrow() ); } - [Fact] + [TestMethod] public void SelectMany_Triple_OnCompletedThrow() { var scheduler = new TestScheduler(); @@ -4270,7 +4273,7 @@ public void SelectMany_Triple_OnCompletedThrow() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SelectMany(null, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc>.Instance)); @@ -4280,7 +4283,7 @@ public void SelectManyWithIndex_Triple_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SelectMany(DummyObservable.Instance, DummyFunc>.Instance, DummyFunc>.Instance, DummyFunc>.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Index() { var scheduler = new TestScheduler(); @@ -4318,7 +4321,7 @@ public void SelectManyWithIndex_Triple_Index() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Identity() { var scheduler = new TestScheduler(); @@ -4354,7 +4357,7 @@ public void SelectManyWithIndex_Triple_Identity() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_InnersWithTiming1() { var scheduler = new TestScheduler(); @@ -4433,7 +4436,7 @@ public void SelectManyWithIndex_Triple_InnersWithTiming1() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_InnersWithTiming2() { var scheduler = new TestScheduler(); @@ -4512,7 +4515,7 @@ public void SelectManyWithIndex_Triple_InnersWithTiming2() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_InnersWithTiming3() { var scheduler = new TestScheduler(); @@ -4591,7 +4594,7 @@ public void SelectManyWithIndex_Triple_InnersWithTiming3() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Error_Identity() { var scheduler = new TestScheduler(); @@ -4629,7 +4632,7 @@ public void SelectManyWithIndex_Triple_Error_Identity() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_SelectMany() { var scheduler = new TestScheduler(); @@ -4671,7 +4674,7 @@ public void SelectManyWithIndex_Triple_SelectMany() } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Concat() { var scheduler = new TestScheduler(); @@ -4710,7 +4713,7 @@ public void SelectManyWithIndex_Triple_Concat() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Catch() { var scheduler = new TestScheduler(); @@ -4746,7 +4749,7 @@ public void SelectManyWithIndex_Triple_Catch() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Error_Catch() { var scheduler = new TestScheduler(); @@ -4785,7 +4788,7 @@ public void SelectManyWithIndex_Triple_Error_Catch() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_All() { var scheduler = new TestScheduler(); @@ -4828,7 +4831,7 @@ public void SelectManyWithIndex_Triple_All() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_Error_All() { var scheduler = new TestScheduler(); @@ -4871,7 +4874,7 @@ public void SelectManyWithIndex_Triple_Error_All() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_All_Dispose() { var scheduler = new TestScheduler(); @@ -4911,7 +4914,7 @@ public void SelectManyWithIndex_Triple_All_Dispose() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_All_Dispose_Before_First() { var scheduler = new TestScheduler(); @@ -4944,7 +4947,7 @@ public void SelectManyWithIndex_Triple_All_Dispose_Before_First() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_OnNextThrow() { var scheduler = new TestScheduler(); @@ -4977,7 +4980,7 @@ public void SelectManyWithIndex_Triple_OnNextThrow() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_OnErrorThrow() { var scheduler = new TestScheduler(); @@ -5014,7 +5017,7 @@ public void SelectManyWithIndex_Triple_OnErrorThrow() ); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Triple_OnCompletedThrow() { var scheduler = new TestScheduler(); @@ -5051,7 +5054,7 @@ public void SelectManyWithIndex_Triple_OnCompletedThrow() ); } - [Fact] + [TestMethod] public void SelectMany_Task_ArgumentChecking() { var t = new Task(() => 42); @@ -5071,21 +5074,21 @@ public void SelectMany_Task_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SelectMany(DummyObservable.Instance, (x, ct) => t, default(Func))); } - [Fact] + [TestMethod] public void SelectMany_Task1() { var res = Observable.Range(0, 10).SelectMany(x => Task.Factory.StartNew(() => x + 1)).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectMany_Task2() { var res = Observable.Range(0, 10).SelectMany((x, ct) => Task.Factory.StartNew(() => x + 1, ct)).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectMany_Task_TaskThrows() { var ex = new Exception(); @@ -5109,7 +5112,7 @@ public void SelectMany_Task_TaskThrows() }); } - [Fact] + [TestMethod] public void SelectMany_Task_SelectorThrows() { var ex = new Exception(); @@ -5133,21 +5136,21 @@ public void SelectMany_Task_SelectorThrows() }); } - [Fact] + [TestMethod] public void SelectMany_Task_ResultSelector1() { var res = Observable.Range(0, 10).SelectMany(x => Task.Factory.StartNew(() => x + 1), (x, y) => x + y).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { 2 * x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectMany_Task_ResultSelector2() { var res = Observable.Range(0, 10).SelectMany((x, ct) => Task.Factory.StartNew(() => x + 1, ct), (x, y) => x + y).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { 2 * x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectMany_Task_ResultSelectorThrows() { var ex = new Exception(); @@ -5171,7 +5174,7 @@ public void SelectMany_Task_ResultSelectorThrows() }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_RanToCompletion_Async() { var tcss = new TaskCompletionSource[2]; @@ -5193,7 +5196,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_RanToCompletion_Async() lst.OrderBy(x => x).AssertEqual(new[] { 42, 43 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_RanToCompletion_Sync() { var tcss = new TaskCompletionSource[2]; @@ -5215,7 +5218,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_RanToCompletion_Sync() lst.OrderBy(x => x).AssertEqual(new[] { 42, 43 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Faulted_Async() { var tcss = new TaskCompletionSource[3]; @@ -5240,7 +5243,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Faulted_Async() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Faulted_Sync() { var tcss = new TaskCompletionSource[3]; @@ -5265,7 +5268,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Faulted_Sync() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Canceled_Async() { var tcss = new TaskCompletionSource[3]; @@ -5289,7 +5292,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Canceled_Async() Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Canceled_Sync() { var tcss = new TaskCompletionSource[3]; @@ -5313,7 +5316,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Canceled_Sync() Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_InnerCompleteBeforeOuter() { var xs = new Subject(); @@ -5346,7 +5349,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_InnerCompleteBeforeOuter( lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_OuterCompleteBeforeInner() { var xs = new Subject(); @@ -5378,7 +5381,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_OuterCompleteBeforeInner( lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_NeverInvoked() { var xs = new Subject(); @@ -5417,7 +5420,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_NeverInvoked lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_Invoked() { var xs = new Subject(); @@ -5463,7 +5466,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_Invoked() Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_AfterOuterError() { var xs = new Subject(); @@ -5509,7 +5512,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_AfterOuterEr Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_AfterSelectorThrows() { var xs = new Subject(); @@ -5564,7 +5567,7 @@ public void SelectMany_TaskWithCompletionSource_Simple_Cancellation_AfterSelecto Assert.Equal(0, m); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_RanToCompletion_Async() { var tcss = new TaskCompletionSource[2]; @@ -5586,7 +5589,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_RanToCompleti lst.OrderBy(x => x).AssertEqual(new[] { 42 + 0, 43 + 1 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_RanToCompletion_Sync() { var tcss = new TaskCompletionSource[2]; @@ -5608,7 +5611,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_RanToCompleti lst.OrderBy(x => x).AssertEqual(new[] { 42 + 0, 43 + 1 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Faulted_Async() { var tcss = new TaskCompletionSource[3]; @@ -5633,7 +5636,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Faulted_Async Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Faulted_Sync() { var tcss = new TaskCompletionSource[3]; @@ -5658,7 +5661,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Faulted_Sync( Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Canceled_Async() { var tcss = new TaskCompletionSource[3]; @@ -5682,7 +5685,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Canceled_Asyn Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Canceled_Sync() { var tcss = new TaskCompletionSource[3]; @@ -5706,7 +5709,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Canceled_Sync Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_InnerCompleteBeforeOuter() { var xs = new Subject(); @@ -5739,7 +5742,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_InnerComplete lst.OrderBy(x => x).AssertEqual(new[] { 42 + 1, 43 + 0, 44 + 2 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_OuterCompleteBeforeInner() { var xs = new Subject(); @@ -5771,7 +5774,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_OuterComplete lst.OrderBy(x => x).AssertEqual(new[] { 42 + 1, 43 + 0, 44 + 2 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_NeverInvoked() { var xs = new Subject(); @@ -5810,7 +5813,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_ lst.OrderBy(x => x).AssertEqual(new[] { 42 + 1, 43 + 0, 44 + 2 }); } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_Invoked() { var xs = new Subject(); @@ -5856,7 +5859,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_ Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_AfterOuterError() { var xs = new Subject(); @@ -5902,7 +5905,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_ Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_AfterSelectorThrows() { var xs = new Subject(); @@ -5957,7 +5960,7 @@ public void SelectMany_TaskWithCompletionSource_WithResultSelector_Cancellation_ Assert.Equal(0, m); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SelectMany(DummyFunc>.Instance)); @@ -5975,49 +5978,49 @@ public void SelectManyWithIndex_Task_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SelectMany(DummyFunc>.Instance, ((Func)null))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_Index() { var res = Observable.Range(0, 10).SelectMany((int x, int i) => Task.Factory.StartNew(() => new { x, i })).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany((x, i) => new[] { new { x, i } }).SequenceEqual(res.OrderBy(v => v.i))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_Cancellation_Index() { var res = Observable.Range(0, 10).SelectMany((x, i, ctx) => Task.Factory.StartNew(() => new { x, i }, ctx)).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany((x, i) => new[] { new { x, i } }).SequenceEqual(res.OrderBy(v => v.i))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_ResultSelector_Index() { var res = Observable.Range(0, 10).SelectMany((int x, int i) => Task.Factory.StartNew(() => new { x, i }), (x, i, r) => r).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany((x, i) => new[] { new { x, i } }).SequenceEqual(res.OrderBy(v => v.i))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_ResultSelector_Cancellation_Index() { var res = Observable.Range(0, 10).SelectMany((x, i, ctx) => Task.Factory.StartNew(() => new { x, i }, ctx), (x, i, r) => r).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany((x, i) => new[] { new { x, i } }).SequenceEqual(res.OrderBy(v => v.i))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task1() { var res = Observable.Range(0, 10).SelectMany((int x, int _) => Task.Factory.StartNew(() => x + 1)).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task2() { var res = Observable.Range(0, 10).SelectMany((x, _, ct) => Task.Factory.StartNew(() => x + 1, ct)).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_TaskThrows() { var ex = new Exception(); @@ -6041,7 +6044,7 @@ public void SelectManyWithIndex_Task_TaskThrows() }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_SelectorThrows() { var ex = new Exception(); @@ -6065,21 +6068,21 @@ public void SelectManyWithIndex_Task_SelectorThrows() }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_ResultSelector1() { var res = Observable.Range(0, 10).SelectMany((x, _) => Task.Factory.StartNew(() => x + 1), (x, _, y) => x + y).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { 2 * x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_ResultSelector2() { var res = Observable.Range(0, 10).SelectMany((x, _, ct) => Task.Factory.StartNew(() => x + 1, ct), (x, _, y) => x + y).ToEnumerable(); Assert.True(Enumerable.Range(0, 10).SelectMany(x => new[] { 2 * x + 1 }).SequenceEqual(res.OrderBy(x => x))); } - [Fact] + [TestMethod] public void SelectManyWithIndex_Task_ResultSelectorThrows() { var ex = new Exception(); @@ -6103,7 +6106,7 @@ public void SelectManyWithIndex_Task_ResultSelectorThrows() }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_RanToCompletion_Async() { var tcss = new TaskCompletionSource[2]; @@ -6125,7 +6128,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_RanToCompletion_ lst.OrderBy(x => x).AssertEqual(new[] { 42, 43 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_RanToCompletion_Sync() { var tcss = new TaskCompletionSource[2]; @@ -6147,7 +6150,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_RanToCompletion_ lst.OrderBy(x => x).AssertEqual(new[] { 42, 43 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Faulted_Async() { var tcss = new TaskCompletionSource[3]; @@ -6172,7 +6175,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Faulted_Async() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Faulted_Sync() { var tcss = new TaskCompletionSource[3]; @@ -6197,7 +6200,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Faulted_Sync() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Canceled_Async() { var tcss = new TaskCompletionSource[3]; @@ -6221,7 +6224,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Canceled_Async() Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Canceled_Sync() { var tcss = new TaskCompletionSource[3]; @@ -6245,7 +6248,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Canceled_Sync() Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_InnerCompleteBeforeOuter() { var xs = new Subject(); @@ -6278,7 +6281,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_InnerCompleteBef lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_OuterCompleteBeforeInner() { var xs = new Subject(); @@ -6310,7 +6313,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_OuterCompleteBef lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_NeverInvoked() { var xs = new Subject(); @@ -6349,7 +6352,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_Nev lst.OrderBy(x => x).AssertEqual(new[] { 42, 43, 44 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_Invoked() { var xs = new Subject(); @@ -6395,7 +6398,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_Inv Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_AfterOuterError() { var xs = new Subject(); @@ -6441,7 +6444,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_Aft Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_AfterSelectorThrows() { var xs = new Subject(); @@ -6496,7 +6499,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_Simple_Cancellation_Aft Assert.Equal(0, m); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_RanToCompletion_Async() { var tcss = new TaskCompletionSource[2]; @@ -6518,7 +6521,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_RanT lst.OrderBy(x => x).AssertEqual(new[] { 42 + 0, 43 + 1 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_RanToCompletion_Sync() { var tcss = new TaskCompletionSource[2]; @@ -6540,7 +6543,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_RanT lst.OrderBy(x => x).AssertEqual(new[] { 42 + 0, 43 + 1 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Faulted_Async() { var tcss = new TaskCompletionSource[3]; @@ -6565,7 +6568,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Faul Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Faulted_Sync() { var tcss = new TaskCompletionSource[3]; @@ -6590,7 +6593,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Faul Assert.Same(ex, err); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canceled_Async() { var tcss = new TaskCompletionSource[3]; @@ -6614,7 +6617,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canc Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canceled_Sync() { var tcss = new TaskCompletionSource[3]; @@ -6638,7 +6641,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canc Assert.True(err is TaskCanceledException && ((TaskCanceledException)err).Task == tcss[1].Task); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_InnerCompleteBeforeOuter() { var xs = new Subject(); @@ -6671,7 +6674,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Inne lst.OrderBy(x => x).AssertEqual(new[] { 42 + 1, 43 + 0, 44 + 2 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_OuterCompleteBeforeInner() { var xs = new Subject(); @@ -6703,7 +6706,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Oute lst.OrderBy(x => x).AssertEqual(new[] { 42 + 1, 43 + 0, 44 + 2 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Cancellation_NeverInvoked() { var xs = new Subject(); @@ -6742,7 +6745,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canc lst.OrderBy(x => x).AssertEqual(new[] { 42 + 1, 43 + 0, 44 + 2 }); } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Cancellation_Invoked() { var xs = new Subject(); @@ -6788,7 +6791,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canc Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Cancellation_AfterOuterError() { var xs = new Subject(); @@ -6834,7 +6837,7 @@ public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Canc Assert.Equal(1, m); // tcss[1] was already finished } - [Fact] + [TestMethod] public void SelectManyWithIndex_TaskWithCompletionSource_WithResultSelector_Cancellation_AfterSelectorThrows() { var xs = new Subject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectTest.cs index 75ea0560e8..59e0a1ca8d 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SelectTest.cs @@ -9,14 +9,17 @@ 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 SelectTest : ReactiveTest { - [Fact] + [TestMethod] public void Select_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).Select(DummyFunc.Instance)); @@ -24,7 +27,7 @@ public void Select_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Select(DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Select_Throws() { ReactiveAssert.Throws(() => @@ -51,7 +54,7 @@ public void Select_Throws() ReactiveAssert.Throws(() => Observable.Create(new Func, Action>(o => { throw new InvalidOperationException(); })).Select(x => x).Subscribe()); } - [Fact] + [TestMethod] public void Select_DisposeInsideSelector() { var scheduler = new TestScheduler(); @@ -95,7 +98,7 @@ public void Select_DisposeInsideSelector() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void Select_Completed() { var scheduler = new TestScheduler(); @@ -137,7 +140,7 @@ public void Select_Completed() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void Select_NotCompleted() { var scheduler = new TestScheduler(); @@ -174,7 +177,7 @@ public void Select_NotCompleted() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void Select_Error() { var scheduler = new TestScheduler(); @@ -218,7 +221,7 @@ public void Select_Error() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void Select_SelectorThrows() { var scheduler = new TestScheduler(); @@ -265,7 +268,7 @@ public void Select_SelectorThrows() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectWithIndex_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).Select(DummyFunc.Instance)); @@ -273,7 +276,7 @@ public void SelectWithIndex_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Select(DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void SelectWithIndex_Throws() { ReactiveAssert.Throws(() => @@ -300,7 +303,7 @@ public void SelectWithIndex_Throws() ReactiveAssert.Throws(() => Observable.Create(new Func, Action>(o => { throw new InvalidOperationException(); })).Select((x, index) => x).Subscribe()); } - [Fact] + [TestMethod] public void SelectWithIndex_DisposeInsideSelector() { var scheduler = new TestScheduler(); @@ -344,7 +347,7 @@ public void SelectWithIndex_DisposeInsideSelector() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SelectWithIndex_Completed() { var scheduler = new TestScheduler(); @@ -386,7 +389,7 @@ public void SelectWithIndex_Completed() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void SelectWithIndex_NotCompleted() { var scheduler = new TestScheduler(); @@ -423,7 +426,7 @@ public void SelectWithIndex_NotCompleted() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void SelectWithIndex_Error() { var scheduler = new TestScheduler(); @@ -466,7 +469,7 @@ public void SelectWithIndex_Error() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void SelectWithIndex_SelectorThrows() { var scheduler = new TestScheduler(); @@ -513,7 +516,7 @@ public void SelectWithIndex_SelectorThrows() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void Select_Select1() { var scheduler = new TestScheduler(); @@ -544,7 +547,7 @@ public void Select_Select1() ); } - [Fact] + [TestMethod] public void Select_Select2() { var scheduler = new TestScheduler(); @@ -575,7 +578,7 @@ public void Select_Select2() ); } - [Fact] + [TestMethod] public void Select_Select3() { var scheduler = new TestScheduler(); @@ -606,7 +609,7 @@ public void Select_Select3() ); } - [Fact] + [TestMethod] public void Select_Select4() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SequenceEqualTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SequenceEqualTest.cs index cfea8c69f5..85b8a3274b 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SequenceEqualTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SequenceEqualTest.cs @@ -8,14 +8,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class SequenceEqualTest : ReactiveTest { - [Fact] + [TestMethod] public void SequenceEqual_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SequenceEqual(default, DummyObservable.Instance)); @@ -31,7 +32,7 @@ public void SequenceEqual_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SequenceEqual(DummyObservable.Instance, new[] { 42 }, default)); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_Equal() { var scheduler = new TestScheduler(); @@ -75,7 +76,7 @@ public void SequenceEqual_Observable_Equal() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_Equal_Sym() { var scheduler = new TestScheduler(); @@ -119,7 +120,7 @@ public void SequenceEqual_Observable_Equal_Sym() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_Left() { var scheduler = new TestScheduler(); @@ -163,7 +164,7 @@ public void SequenceEqual_Observable_NotEqual_Left() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_Left_Sym() { var scheduler = new TestScheduler(); @@ -207,7 +208,7 @@ public void SequenceEqual_Observable_NotEqual_Left_Sym() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_Right() { var scheduler = new TestScheduler(); @@ -251,7 +252,7 @@ public void SequenceEqual_Observable_NotEqual_Right() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_Right_Sym() { var scheduler = new TestScheduler(); @@ -295,7 +296,7 @@ public void SequenceEqual_Observable_NotEqual_Right_Sym() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_2() { var scheduler = new TestScheduler(); @@ -347,7 +348,7 @@ public void SequenceEqual_Observable_NotEqual_2() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_2_Sym() { var scheduler = new TestScheduler(); @@ -399,7 +400,7 @@ public void SequenceEqual_Observable_NotEqual_2_Sym() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_3() { var scheduler = new TestScheduler(); @@ -438,7 +439,7 @@ public void SequenceEqual_Observable_NotEqual_3() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_3_Sym() { var scheduler = new TestScheduler(); @@ -477,7 +478,7 @@ public void SequenceEqual_Observable_NotEqual_3_Sym() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_ComparerThrows() { var scheduler = new TestScheduler(); @@ -517,7 +518,7 @@ public void SequenceEqual_Observable_ComparerThrows() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_ComparerThrows_Sym() { var scheduler = new TestScheduler(); @@ -577,7 +578,7 @@ public int GetHashCode(int obj) } } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_4() { var scheduler = new TestScheduler(); @@ -611,7 +612,7 @@ public void SequenceEqual_Observable_NotEqual_4() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_NotEqual_4_Sym() { var scheduler = new TestScheduler(); @@ -645,7 +646,7 @@ public void SequenceEqual_Observable_NotEqual_4_Sym() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_Left_Throw() { var scheduler = new TestScheduler(); @@ -680,7 +681,7 @@ public void SequenceEqual_Observable_Left_Throw() ); } - [Fact] + [TestMethod] public void SequenceEqual_Observable_Right_Throw() { var scheduler = new TestScheduler(); @@ -715,7 +716,7 @@ public void SequenceEqual_Observable_Right_Throw() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_Equal() { var scheduler = new TestScheduler(); @@ -745,7 +746,7 @@ public void SequenceEqual_Enumerable_Equal() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_NotEqual_Elements() { var scheduler = new TestScheduler(); @@ -775,7 +776,7 @@ public void SequenceEqual_Enumerable_NotEqual_Elements() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_Comparer_Equal() { var scheduler = new TestScheduler(); @@ -805,7 +806,7 @@ public void SequenceEqual_Enumerable_Comparer_Equal() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_Comparer_NotEqual() { var scheduler = new TestScheduler(); @@ -848,7 +849,7 @@ public int GetHashCode(int obj) } } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_Comparer_Throws() { var scheduler = new TestScheduler(); @@ -906,7 +907,7 @@ public int GetHashCode(int obj) } } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_NotEqual_TooLong() { var scheduler = new TestScheduler(); @@ -936,7 +937,7 @@ public void SequenceEqual_Enumerable_NotEqual_TooLong() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_NotEqual_TooShort() { var scheduler = new TestScheduler(); @@ -966,7 +967,7 @@ public void SequenceEqual_Enumerable_NotEqual_TooShort() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_OnError() { var ex = new Exception(); @@ -994,7 +995,7 @@ public void SequenceEqual_Enumerable_OnError() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_IteratorThrows1() { var ex = new Exception(); @@ -1022,7 +1023,7 @@ public void SequenceEqual_Enumerable_IteratorThrows1() ); } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_IteratorThrows2() { var ex = new Exception(); @@ -1055,7 +1056,7 @@ private IEnumerable Throw(Exception ex) throw ex; } - [Fact] + [TestMethod] public void SequenceEqual_Enumerable_GetEnumeratorThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleAsyncTest.cs index c993a7f6d1..0df01fd1f7 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleAsyncTest.cs @@ -9,14 +9,17 @@ using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { + [TestClass] public class SingleAsyncTest : ReactiveTest { - [Fact] + [TestMethod] public void SingleAsync_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SingleAsync(default(IObservable))); @@ -24,7 +27,7 @@ public void SingleAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SingleAsync(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void SingleAsync_Empty() { var scheduler = new TestScheduler(); @@ -47,7 +50,7 @@ public void SingleAsync_Empty() ); } - [Fact] + [TestMethod] public void SingleAsync_One() { var scheduler = new TestScheduler(); @@ -72,7 +75,7 @@ public void SingleAsync_One() ); } - [Fact] + [TestMethod] public void SingleAsync_Many() { var scheduler = new TestScheduler(); @@ -97,7 +100,7 @@ public void SingleAsync_Many() ); } - [Fact] + [TestMethod] public void SingleAsync_Error() { var scheduler = new TestScheduler(); @@ -122,7 +125,7 @@ public void SingleAsync_Error() ); } - [Fact] + [TestMethod] public void SingleAsync_Predicate() { var scheduler = new TestScheduler(); @@ -149,7 +152,7 @@ public void SingleAsync_Predicate() ); } - [Fact] + [TestMethod] public void SingleAsync_Predicate_Empty() { var scheduler = new TestScheduler(); @@ -174,7 +177,7 @@ public void SingleAsync_Predicate_Empty() ); } - [Fact] + [TestMethod] public void SingleAsync_Predicate_One() { var scheduler = new TestScheduler(); @@ -202,7 +205,7 @@ public void SingleAsync_Predicate_One() ); } - [Fact] + [TestMethod] public void SingleAsync_Predicate_Throw() { var scheduler = new TestScheduler(); @@ -227,7 +230,7 @@ public void SingleAsync_Predicate_Throw() ); } - [Fact] + [TestMethod] public void SingleAsync_PredicateThrows() { var scheduler = new TestScheduler(); @@ -256,7 +259,7 @@ public void SingleAsync_PredicateThrows() ); } - [Fact] // https://github.com/dotnet/reactive/issues/1235 + [TestMethod] // https://github.com/dotnet/reactive/issues/1235 public void MeaningfulStackTrace() { static async Task Core() diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultAsyncTest.cs index dcc2a51c29..baba4eee44 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultAsyncTest.cs @@ -6,14 +6,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class SingleOrAsyncTestTest : ReactiveTest { - [Fact] + [TestMethod] public void SingleOrDefaultAsync_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SingleOrDefaultAsync(default(IObservable))); @@ -21,7 +22,7 @@ public void SingleOrDefaultAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SingleOrDefaultAsync(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Empty() { var scheduler = new TestScheduler(); @@ -45,7 +46,7 @@ public void SingleOrDefaultAsync_Empty() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_One() { var scheduler = new TestScheduler(); @@ -70,7 +71,7 @@ public void SingleOrDefaultAsync_One() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Many() { var scheduler = new TestScheduler(); @@ -95,7 +96,7 @@ public void SingleOrDefaultAsync_Many() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Error() { var scheduler = new TestScheduler(); @@ -120,7 +121,7 @@ public void SingleOrDefaultAsync_Error() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Predicate() { var scheduler = new TestScheduler(); @@ -149,7 +150,7 @@ public void SingleOrDefaultAsync_Predicate() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Predicate_Empty() { var scheduler = new TestScheduler(); @@ -175,7 +176,7 @@ public void SingleOrDefaultAsync_Predicate_Empty() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Predicate_One() { var scheduler = new TestScheduler(); @@ -205,7 +206,7 @@ public void SingleOrDefaultAsync_Predicate_One() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Predicate_None() { var scheduler = new TestScheduler(); @@ -235,7 +236,7 @@ public void SingleOrDefaultAsync_Predicate_None() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_Predicate_Throw() { var scheduler = new TestScheduler(); @@ -260,7 +261,7 @@ public void SingleOrDefaultAsync_Predicate_Throw() ); } - [Fact] + [TestMethod] public void SingleOrDefaultAsync_PredicateThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultTest.cs index 69e0fd5a66..be6129c987 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleOrDefaultTest.cs @@ -7,14 +7,17 @@ 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 SingleOrDefaultTest : ReactiveTest { - [Fact] + [TestMethod] public void SingleOrDefault_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SingleOrDefault(default(IObservable))); @@ -22,26 +25,26 @@ public void SingleOrDefault_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SingleOrDefault(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void SingleOrDefault_Empty() { Assert.Equal(default, Observable.Empty().SingleOrDefault()); } - [Fact] + [TestMethod] public void SingleOrDefaultPredicate_Empty() { Assert.Equal(default, Observable.Empty().SingleOrDefault(_ => true)); } - [Fact] + [TestMethod] public void SingleOrDefault_Return() { var value = 42; Assert.Equal(value, Observable.Return(value).SingleOrDefault()); } - [Fact] + [TestMethod] public void SingleOrDefault_Throw() { var ex = new Exception(); @@ -51,28 +54,28 @@ public void SingleOrDefault_Throw() ReactiveAssert.Throws(ex, () => xs.SingleOrDefault()); } - [Fact] + [TestMethod] public void SingleOrDefault_Range() { var value = 42; ReactiveAssert.Throws(() => Observable.Range(value, 10).SingleOrDefault()); } - [Fact] + [TestMethod] public void SingleOrDefaultPredicate_Range() { var value = 42; ReactiveAssert.Throws(() => Observable.Range(value, 10).SingleOrDefault(i => i % 2 == 0)); } - [Fact] + [TestMethod] public void SingleOrDefault_Range_ReducesToSingle() { var value = 42; Assert.Equal(45, Observable.Range(value, 10).SingleOrDefault(i => i == 45)); } - [Fact] + [TestMethod] public void SingleOrDefault_Range_ReducesToNone() { var value = 42; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleTest.cs index 4c8b0b43e9..ca916acd8e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SingleTest.cs @@ -7,14 +7,17 @@ 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 SingleTest : ReactiveTest { - [Fact] + [TestMethod] public void Single_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Single(default(IObservable))); @@ -22,26 +25,26 @@ public void Single_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Single(DummyObservable.Instance, default)); } - [Fact] + [TestMethod] public void Single_Empty() { ReactiveAssert.Throws(() => Observable.Empty().Single()); } - [Fact] + [TestMethod] public void SinglePredicate_Empty() { ReactiveAssert.Throws(() => Observable.Empty().Single(_ => true)); } - [Fact] + [TestMethod] public void Single_Return() { var value = 42; Assert.Equal(value, Observable.Return(value).Single()); } - [Fact] + [TestMethod] public void Single_Throw() { var ex = new Exception(); @@ -51,21 +54,21 @@ public void Single_Throw() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void Single_Range() { var value = 42; ReactiveAssert.Throws(() => Observable.Range(value, 10).Single()); } - [Fact] + [TestMethod] public void SinglePredicate_Range() { var value = 42; ReactiveAssert.Throws(() => Observable.Range(value, 10).Single(i => i % 2 == 0)); } - [Fact] + [TestMethod] public void SinglePredicate_Range_ReducesToSingle() { var value = 42; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipLastTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipLastTest.cs index a16c22c364..76f539e8ef 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipLastTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipLastTest.cs @@ -10,23 +10,26 @@ using System.Threading; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { #region + Count + + [TestClass] public class SkipLastTest : ReactiveTest { - [Fact] + [TestMethod] public void SkipLast_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SkipLast(null, 0)); ReactiveAssert.Throws(() => Observable.SkipLast(DummyObservable.Instance, -1)); } - [Fact] + [TestMethod] public void SkipLast_Zero_Completed() { var scheduler = new TestScheduler(); @@ -65,7 +68,7 @@ public void SkipLast_Zero_Completed() ); } - [Fact] + [TestMethod] public void SkipLast_Zero_Error() { var scheduler = new TestScheduler(); @@ -106,7 +109,7 @@ public void SkipLast_Zero_Error() ); } - [Fact] + [TestMethod] public void SkipLast_Zero_Disposed() { var scheduler = new TestScheduler(); @@ -143,7 +146,7 @@ public void SkipLast_Zero_Disposed() ); } - [Fact] + [TestMethod] public void SkipLast_One_Completed() { var scheduler = new TestScheduler(); @@ -181,7 +184,7 @@ public void SkipLast_One_Completed() ); } - [Fact] + [TestMethod] public void SkipLast_One_Error() { var scheduler = new TestScheduler(); @@ -221,7 +224,7 @@ public void SkipLast_One_Error() ); } - [Fact] + [TestMethod] public void SkipLast_One_Disposed() { var scheduler = new TestScheduler(); @@ -257,7 +260,7 @@ public void SkipLast_One_Disposed() ); } - [Fact] + [TestMethod] public void SkipLast_Three_Completed() { var scheduler = new TestScheduler(); @@ -293,7 +296,7 @@ public void SkipLast_Three_Completed() ); } - [Fact] + [TestMethod] public void SkipLast_Three_Error() { var scheduler = new TestScheduler(); @@ -331,7 +334,7 @@ public void SkipLast_Three_Error() ); } - [Fact] + [TestMethod] public void SkipLast_Three_Disposed() { var scheduler = new TestScheduler(); @@ -369,7 +372,7 @@ public void SkipLast_Three_Disposed() #region + Timed + - [Fact] + [TestMethod] public void SkipLast_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -382,7 +385,7 @@ public void SkipLast_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SkipLast(xs, TimeSpan.FromSeconds(-1), Scheduler.Default)); } - [Fact] + [TestMethod] public void SkipLast_Zero1() { var scheduler = new TestScheduler(); @@ -408,7 +411,7 @@ public void SkipLast_Zero1() ); } - [Fact] + [TestMethod] public void SkipLast_Zero2() { var scheduler = new TestScheduler(); @@ -436,7 +439,7 @@ public void SkipLast_Zero2() ); } - [Fact] + [TestMethod] public void SkipLast_Some1() { var scheduler = new TestScheduler(); @@ -461,7 +464,7 @@ public void SkipLast_Some1() ); } - [Fact] + [TestMethod] public void SkipLast_Some2() { var scheduler = new TestScheduler(); @@ -497,7 +500,7 @@ public void SkipLast_Some2() ); } - [Fact] + [TestMethod] public void SkipLast_All() { var scheduler = new TestScheduler(); @@ -521,7 +524,7 @@ public void SkipLast_All() ); } - [Fact] + [TestMethod] public void SkipLast_Error() { var scheduler = new TestScheduler(); @@ -545,7 +548,7 @@ public void SkipLast_Error() ); } - [Fact] + [TestMethod] public void SkipLast_Never() { var scheduler = new TestScheduler(); @@ -567,7 +570,7 @@ public void SkipLast_Never() ); } - [Fact] + [TestMethod] public void SkipLast_Default1() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -587,7 +590,7 @@ public void SkipLast_Default1() Assert.True(lst.Count == 0); } - [Fact] + [TestMethod] public void SkipLast_Default2() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -607,7 +610,7 @@ public void SkipLast_Default2() Assert.True(lst.Count == 0); } - [Fact] + [TestMethod] public void SkipLast_Default3() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -627,7 +630,7 @@ public void SkipLast_Default3() Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void SkipLast_Default4() { var xs = Observable.Range(0, 10, Scheduler.Default); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipTest.cs index 8c9bc9ba1a..bb2602db2c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipTest.cs @@ -10,16 +10,19 @@ 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 SkipTest : ReactiveTest { #region + Count + - [Fact] + [TestMethod] public void Skip_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).Skip(0)); @@ -27,7 +30,7 @@ public void Skip_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Skip(0).Subscribe(null)); } - [Fact] + [TestMethod] public void Skip_Complete_After() { var scheduler = new TestScheduler(); @@ -68,7 +71,7 @@ public void Skip_Complete_After() ); } - [Fact] + [TestMethod] public void Skip_Complete_Same() { var scheduler = new TestScheduler(); @@ -109,7 +112,7 @@ public void Skip_Complete_Same() ); } - [Fact] + [TestMethod] public void Skip_Complete_Before() { var scheduler = new TestScheduler(); @@ -157,7 +160,7 @@ public void Skip_Complete_Before() ); } - [Fact] + [TestMethod] public void Skip_Complete_Zero() { var scheduler = new TestScheduler(); @@ -215,7 +218,7 @@ public void Skip_Complete_Zero() ); } - [Fact] + [TestMethod] public void Skip_Error_After() { var scheduler = new TestScheduler(); @@ -258,7 +261,7 @@ public void Skip_Error_After() ); } - [Fact] + [TestMethod] public void Skip_Error_Same() { var scheduler = new TestScheduler(); @@ -301,7 +304,7 @@ public void Skip_Error_Same() ); } - [Fact] + [TestMethod] public void Skip_Error_Before() { var scheduler = new TestScheduler(); @@ -358,7 +361,7 @@ public void Skip_Error_Before() ); } - [Fact] + [TestMethod] public void Skip_Dispose_Before() { var scheduler = new TestScheduler(); @@ -398,7 +401,7 @@ public void Skip_Dispose_Before() ); } - [Fact] + [TestMethod] public void Skip_Dispose_After() { var scheduler = new TestScheduler(); @@ -443,7 +446,7 @@ public void Skip_Dispose_After() ); } - [Fact] + [TestMethod] public void Skip_Skip1() { var scheduler = new TestScheduler(); @@ -482,7 +485,7 @@ public void Skip_Skip1() #region + Timed + - [Fact] + [TestMethod] public void Skip_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -495,7 +498,7 @@ public void Skip_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Skip(xs, TimeSpan.FromSeconds(-1), Scheduler.Default)); } - [Fact] + [TestMethod] public void Skip_Zero() { var scheduler = new TestScheduler(); @@ -521,7 +524,7 @@ public void Skip_Zero() ); } - [Fact] + [TestMethod] public void Skip_Some() { var scheduler = new TestScheduler(); @@ -546,7 +549,7 @@ public void Skip_Some() ); } - [Fact] + [TestMethod] public void Skip_Late() { var scheduler = new TestScheduler(); @@ -570,7 +573,7 @@ public void Skip_Late() ); } - [Fact] + [TestMethod] public void Skip_Error() { var scheduler = new TestScheduler(); @@ -594,7 +597,7 @@ public void Skip_Error() ); } - [Fact] + [TestMethod] public void Skip_Never() { var scheduler = new TestScheduler(); @@ -616,7 +619,7 @@ public void Skip_Never() ); } - [Fact] + [TestMethod] public void Skip_Twice1() { var scheduler = new TestScheduler(); @@ -649,7 +652,7 @@ public void Skip_Twice1() ); } - [Fact] + [TestMethod] public void Skip_Twice2() { var scheduler = new TestScheduler(); @@ -682,7 +685,7 @@ public void Skip_Twice2() ); } - [Fact] + [TestMethod] public void Skip_Default() { var xs = Observable.Range(0, 10, Scheduler.Default); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipUntilTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipUntilTest.cs index 2800a2dca9..f15c817fa2 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipUntilTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipUntilTest.cs @@ -9,21 +9,24 @@ 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 SkipUntilTest : ReactiveTest { #region + Observable + - [Fact] + [TestMethod] public void SkipUntil_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SkipUntil(null, DummyObservable.Instance)); ReactiveAssert.Throws(() => Observable.SkipUntil(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void SkipUntil_SomeData_Next() { var scheduler = new TestScheduler(); @@ -62,7 +65,7 @@ public void SkipUntil_SomeData_Next() ); } - [Fact] + [TestMethod] public void SkipUntil_SomeData_Error() { var scheduler = new TestScheduler(); @@ -100,7 +103,7 @@ public void SkipUntil_SomeData_Error() ); } - [Fact] + [TestMethod] public void SkipUntil_Error_SomeData() { var scheduler = new TestScheduler(); @@ -136,7 +139,7 @@ public void SkipUntil_Error_SomeData() ); } - [Fact] + [TestMethod] public void SkipUntil_SomeData_Empty() { var scheduler = new TestScheduler(); @@ -171,7 +174,7 @@ public void SkipUntil_SomeData_Empty() ); } - [Fact] + [TestMethod] public void SkipUntil_Never_Next() { var scheduler = new TestScheduler(); @@ -202,7 +205,7 @@ public void SkipUntil_Never_Next() ); } - [Fact] + [TestMethod] public void SkipUntil_Never_Error1() { var scheduler = new TestScheduler(); @@ -235,7 +238,7 @@ public void SkipUntil_Never_Error1() ); } - [Fact] + [TestMethod] public void SkipUntil_SomeData_Error2() { var scheduler = new TestScheduler(); @@ -273,7 +276,7 @@ public void SkipUntil_SomeData_Error2() ); } - [Fact] + [TestMethod] public void SkipUntil_SomeData_Never() { var scheduler = new TestScheduler(); @@ -307,7 +310,7 @@ public void SkipUntil_SomeData_Never() ); } - [Fact] + [TestMethod] public void SkipUntil_Never_Empty() { var scheduler = new TestScheduler(); @@ -337,7 +340,7 @@ public void SkipUntil_Never_Empty() ); } - [Fact] + [TestMethod] public void SkipUntil_Never_Never() { var scheduler = new TestScheduler(); @@ -366,7 +369,7 @@ public void SkipUntil_Never_Never() ); } - [Fact] + [TestMethod] public void SkipUntil_HasCompletedCausesDisposal() { var scheduler = new TestScheduler(); @@ -394,7 +397,7 @@ public void SkipUntil_HasCompletedCausesDisposal() Assert.True(disposed, "disposed"); } - [Fact] + [TestMethod] public void SkipUntil_Immediate() { var scheduler = new TestScheduler(); @@ -412,7 +415,7 @@ public void SkipUntil_Immediate() ); } - [Fact] // Asserts behaviour considered buggy. A fix is desirable but breaking. + [TestMethod] // Asserts behaviour considered buggy. A fix is desirable but breaking. public void SkipUntil_Empty_Empty() { var scheduler = new TestScheduler(); @@ -440,7 +443,7 @@ public void SkipUntil_Empty_Empty() #region + Timed + - [Fact] + [TestMethod] public void SkipUntil_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -451,7 +454,7 @@ public void SkipUntil_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.SkipUntil(xs, DateTimeOffset.Now, default)); } - [Fact] + [TestMethod] public void SkipUntil_Zero() { var scheduler = new TestScheduler(); @@ -477,7 +480,7 @@ public void SkipUntil_Zero() ); } - [Fact] + [TestMethod] public void SkipUntil_Some() { var scheduler = new TestScheduler(); @@ -502,7 +505,7 @@ public void SkipUntil_Some() ); } - [Fact] + [TestMethod] public void SkipUntil_Late() { var scheduler = new TestScheduler(); @@ -526,7 +529,7 @@ public void SkipUntil_Late() ); } - [Fact] + [TestMethod] public void SkipUntil_Error() { var scheduler = new TestScheduler(); @@ -550,7 +553,7 @@ public void SkipUntil_Error() ); } - [Fact] + [TestMethod] public void SkipUntil_Never() { var scheduler = new TestScheduler(); @@ -572,7 +575,7 @@ public void SkipUntil_Never() ); } - [Fact] + [TestMethod] public void SkipUntil_Twice1() { var scheduler = new TestScheduler(); @@ -605,7 +608,7 @@ public void SkipUntil_Twice1() ); } - [Fact] + [TestMethod] public void SkipUntil_Twice2() { var scheduler = new TestScheduler(); @@ -638,7 +641,7 @@ public void SkipUntil_Twice2() ); } - [Fact] + [TestMethod] public void SkipUntil_Default() { var xs = Observable.Range(0, 10, Scheduler.Default); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipWhileTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipWhileTest.cs index ac32f5aaf7..cd3a8d8b67 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipWhileTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SkipWhileTest.cs @@ -7,14 +7,17 @@ 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 SkipWhileTest : ReactiveTest { - [Fact] + [TestMethod] public void SkipWhile_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).SkipWhile(DummyFunc.Instance)); @@ -24,7 +27,7 @@ public void SkipWhile_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.SkipWhile(default(Func))); } - [Fact] + [TestMethod] public void SkipWhile_Complete_Before() { var scheduler = new TestScheduler(); @@ -66,7 +69,7 @@ public void SkipWhile_Complete_Before() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Complete_After() { var scheduler = new TestScheduler(); @@ -111,7 +114,7 @@ public void SkipWhile_Complete_After() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Error_Before() { var scheduler = new TestScheduler(); @@ -154,7 +157,7 @@ public void SkipWhile_Error_Before() Assert.Equal(2, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Error_After() { var scheduler = new TestScheduler(); @@ -201,7 +204,7 @@ public void SkipWhile_Error_After() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Dispose_Before() { var scheduler = new TestScheduler(); @@ -242,7 +245,7 @@ public void SkipWhile_Dispose_Before() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Dispose_After() { var scheduler = new TestScheduler(); @@ -286,7 +289,7 @@ public void SkipWhile_Dispose_After() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Zero() { var scheduler = new TestScheduler(); @@ -338,7 +341,7 @@ public void SkipWhile_Zero() Assert.Equal(1, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Throw() { var scheduler = new TestScheduler(); @@ -385,7 +388,7 @@ public void SkipWhile_Throw() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void SkipWhile_Index() { var scheduler = new TestScheduler(); @@ -424,7 +427,7 @@ public void SkipWhile_Index() ); } - [Fact] + [TestMethod] public void SkipWhile_Index_Throw() { var scheduler = new TestScheduler(); @@ -459,7 +462,7 @@ public void SkipWhile_Index_Throw() ); } - [Fact] + [TestMethod] public void SkipWhile_Index_SelectorThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartAsyncTest.cs index 189c324f79..f5122c40d6 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartAsyncTest.cs @@ -10,10 +10,13 @@ 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 StartAsyncTest : ReactiveTest { @@ -28,7 +31,7 @@ public StartAsyncTest() #region Func - [Fact] + [TestMethod] public void StartAsync_Func_ArgumentChecking() { var s = Scheduler.Immediate; @@ -43,7 +46,7 @@ public void StartAsync_Func_ArgumentChecking() ReactiveAssert.Throws(() => Observable.StartAsync(ct => _doneTask, default)); } - [Fact] + [TestMethod] public void StartAsync_Func_Success() { var n = 42; @@ -63,7 +66,7 @@ public void StartAsync_Func_Success() Assert.Equal(1, i); } - [Fact] + [TestMethod] public void StartAsync_Func_Throw_Synchronous() { var ex = new Exception(); @@ -76,7 +79,7 @@ public void StartAsync_Func_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_Func_Throw_Asynchronous() { var ex = new Exception(); @@ -91,7 +94,7 @@ public void StartAsync_Func_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_FuncWithCancel_Success() { var n = 42; @@ -110,7 +113,7 @@ public void StartAsync_FuncWithCancel_Success() Assert.Equal(1, i); } - [Fact] + [TestMethod] public void StartAsync_FuncWithCancel_Throw_Synchronous() { var ex = new Exception(); @@ -123,7 +126,7 @@ public void StartAsync_FuncWithCancel_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_FuncWithCancel_Throw_Asynchronous() { var ex = new Exception(); @@ -135,7 +138,7 @@ public void StartAsync_FuncWithCancel_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_FuncWithCancel_Cancel() { var N = 10; @@ -180,7 +183,7 @@ public void StartAsync_FuncWithCancel_Cancel() } #if DESKTOPCLR - [Fact] + [TestMethod] public void StartAsync_Func_Scheduler1() { var tcs = new TaskCompletionSource(); @@ -205,7 +208,7 @@ public void StartAsync_Func_Scheduler1() Assert.Equal(Thread.CurrentThread.ManagedThreadId, t); } - [Fact] + [TestMethod] public void StartAsync_Func_Scheduler2() { var tcs = new TaskCompletionSource(); @@ -235,7 +238,7 @@ public void StartAsync_Func_Scheduler2() #region Action - [Fact] + [TestMethod] public void StartAsync_Action_ArgumentChecking() { var s = Scheduler.Immediate; @@ -249,7 +252,7 @@ public void StartAsync_Action_ArgumentChecking() ReactiveAssert.Throws(() => Observable.StartAsync(ct => (Task)_doneTask, default)); } - [Fact] + [TestMethod] public void StartAsync_Action_Success() { var i = 0; @@ -266,7 +269,7 @@ public void StartAsync_Action_Success() Assert.Equal(1, i); } - [Fact] + [TestMethod] public void StartAsync_Action_Throw_Synchronous() { var ex = new Exception(); @@ -279,7 +282,7 @@ public void StartAsync_Action_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_Action_Throw_Asynchronous() { var ex = new Exception(); @@ -291,7 +294,7 @@ public void StartAsync_Action_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_ActionWithCancel_Success() { var i = 0; @@ -308,7 +311,7 @@ public void StartAsync_ActionWithCancel_Success() Assert.Equal(1, i); } - [Fact] + [TestMethod] public void StartAsync_ActionWithCancel_Throw_Synchronous() { var ex = new Exception(); @@ -321,7 +324,7 @@ public void StartAsync_ActionWithCancel_Throw_Synchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_ActionWithCancel_Throw_Asynchronous() { var ex = new Exception(); @@ -333,7 +336,7 @@ public void StartAsync_ActionWithCancel_Throw_Asynchronous() ReactiveAssert.Throws(ex, () => xs.Single()); } - [Fact] + [TestMethod] public void StartAsync_ActionWithCancel_Cancel() { var N = 10; @@ -378,7 +381,7 @@ public void StartAsync_ActionWithCancel_Cancel() } #if DESKTOPCLR - [Fact] + [TestMethod] public void StartAsync_Action_Scheduler1() { var tcs = new TaskCompletionSource(); @@ -400,7 +403,7 @@ public void StartAsync_Action_Scheduler1() Assert.Equal(Thread.CurrentThread.ManagedThreadId, t); } - [Fact] + [TestMethod] public void StartAsync_Action_Scheduler2() { var tcs = new TaskCompletionSource(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartTest.cs index 152fb5aa59..03983ff12b 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartTest.cs @@ -7,14 +7,17 @@ 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 StartTest : ReactiveTest { - [Fact] + [TestMethod] public void Start_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Start(null)); @@ -28,7 +31,7 @@ public void Start_ArgumentChecking() } - [Fact] + [TestMethod] public void Start_Action() { var done = false; @@ -36,7 +39,7 @@ public void Start_Action() Assert.True(done, "done"); } - [Fact] + [TestMethod] public void Start_Action2() { var scheduler = new TestScheduler(); @@ -55,7 +58,7 @@ public void Start_Action2() Assert.True(done, "done"); } - [Fact] + [TestMethod] public void Start_ActionError() { var ex = new Exception(); @@ -67,7 +70,7 @@ public void Start_ActionError() })); } - [Fact] + [TestMethod] public void Start_Func() { var res = Observable.Start(() => 1).ToEnumerable(); @@ -77,7 +80,7 @@ public void Start_Func() })); } - [Fact] + [TestMethod] public void Start_Func2() { var scheduler = new TestScheduler(); @@ -92,7 +95,7 @@ public void Start_Func2() ); } - [Fact] + [TestMethod] public void Start_FuncError() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartWithTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartWithTest.cs index cdea1d861d..fea51643f0 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartWithTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/StartWithTest.cs @@ -7,14 +7,15 @@ 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 StartWithTest : ReactiveTest { - [Fact] + [TestMethod] public void StartWith_ArgumentChecking() { var values = (IEnumerable)new[] { 1, 2, 3 }; @@ -37,7 +38,7 @@ public void StartWith_ArgumentChecking() ReactiveAssert.Throws(() => Observable.StartWith(someObservable, scheduler, default(IEnumerable))); } - [Fact] + [TestMethod] public void StartWith() { var scheduler = new TestScheduler(); @@ -59,7 +60,7 @@ public void StartWith() ); } - [Fact] + [TestMethod] public void StartWith_Scheduler() { var scheduler = new TestScheduler(); @@ -83,7 +84,7 @@ public void StartWith_Scheduler() ); } - [Fact] + [TestMethod] public void StartWith_Enumerable() { var scheduler = new TestScheduler(); @@ -108,7 +109,7 @@ public void StartWith_Enumerable() ); } - [Fact] + [TestMethod] public void StartWith_Enumerable_Scheduler() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeOnTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeOnTest.cs index 06c799227c..7761320ad3 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeOnTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeOnTest.cs @@ -8,7 +8,7 @@ using System.Threading; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; #if HAS_DISPATCHER using System.Windows.Threading; @@ -21,15 +21,17 @@ using System.Windows.Forms; #endif +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { + [TestClass] public class SubscribeOnTest : TestBase { #region + TestBase + - [Fact] + [TestMethod] public void SubscribeOn_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -54,7 +56,7 @@ public void SubscribeOn_ArgumentChecking() } #if HAS_WINFORMS - [Fact] + [TestMethod] public void SubscribeOn_Control() { bool okay = true; @@ -88,7 +90,7 @@ public void SubscribeOn_Control() Assert.True(okay); } - [Fact] + [TestMethod] public void SubscribeOn_ControlScheduler() { bool okay = true; @@ -125,7 +127,7 @@ public void SubscribeOn_ControlScheduler() #endif #if HAS_DISPATCHER - [Fact] + [TestMethod] [Asynchronous] public void SubscribeOn_Dispatcher() { @@ -156,7 +158,7 @@ public void SubscribeOn_Dispatcher() } } - [Fact] + [TestMethod] [Asynchronous] public void SubscribeOn_DispatcherScheduler() { @@ -187,7 +189,7 @@ public void SubscribeOn_DispatcherScheduler() } } - [Fact] + [TestMethod] [Asynchronous] public void SubscribeOn_CurrentDispatcher() { @@ -227,17 +229,18 @@ public void SubscribeOn_CurrentDispatcher() } + [TestClass] public class SubscribeOnReactiveTest : ReactiveTest { - [Fact] + [TestMethod] public void SubscribeOn_Scheduler_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.SubscribeOn(default(IObservable), DummyScheduler.Instance)); ReactiveAssert.Throws(() => Observable.SubscribeOn(DummyObservable.Instance, default(IScheduler))); } - [Fact] + [TestMethod] public void SubscribeOn_Scheduler_Sleep() { var scheduler = new TestScheduler(); @@ -262,7 +265,7 @@ public void SubscribeOn_Scheduler_Sleep() Assert.Equal(1001, d); } - [Fact] + [TestMethod] public void SubscribeOn_Scheduler_Completed() { var scheduler = new TestScheduler(); @@ -284,7 +287,7 @@ public void SubscribeOn_Scheduler_Completed() ); } - [Fact] + [TestMethod] public void SubscribeOn_Scheduler_Error() { var scheduler = new TestScheduler(); @@ -308,7 +311,7 @@ public void SubscribeOn_Scheduler_Error() ); } - [Fact] + [TestMethod] public void SubscribeOn_Scheduler_Dispose() { var scheduler = new TestScheduler(); @@ -328,7 +331,7 @@ public void SubscribeOn_Scheduler_Dispose() ); } - [Fact] + [TestMethod] public void SubscribeOn_SynchronizationContext_Simple() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeTest.cs index f70d57c9c9..9375d1b2f9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SubscribeTest.cs @@ -10,14 +10,17 @@ 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 SubscribeTest : ReactiveTest { - [Fact] + [TestMethod] public void SubscribeToEnumerable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Subscribe(null, DummyObserver.Instance)); @@ -29,7 +32,7 @@ public void SubscribeToEnumerable_ArgumentChecking() ReactiveAssert.Throws(() => NullEnumeratorEnumerable.Instance.Subscribe(Observer.Create(x => { }), Scheduler.CurrentThread)); } - [Fact] + [TestMethod] public void SubscribeToEnumerable_Finite() { var scheduler = new TestScheduler(); @@ -58,7 +61,7 @@ public void SubscribeToEnumerable_Finite() ); } - [Fact] + [TestMethod] public void SubscribeToEnumerable_Infinite() { var scheduler = new TestScheduler(); @@ -90,7 +93,7 @@ public void SubscribeToEnumerable_Infinite() ); } - [Fact] + [TestMethod] public void SubscribeToEnumerable_Error() { var scheduler = new TestScheduler(); @@ -118,7 +121,7 @@ public void SubscribeToEnumerable_Error() ); } - [Fact] + [TestMethod] public void SubscribeToEnumerable_DefaultScheduler() { for (var i = 0; i < 100; i++) @@ -172,7 +175,7 @@ private IEnumerable Enumerable_Error(Exception exception) #region Subscribe - [Fact] + [TestMethod] public void Subscribe_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -196,13 +199,13 @@ public void Subscribe_ArgumentChecking() ReactiveAssert.Throws(() => ObservableExtensions.Subscribe(someObservable, _ => { }, (Exception _) => { }, default(Action))); } - [Fact] + [TestMethod] public void Subscribe_None_Return() { Observable.Return(1, Scheduler.Immediate).Subscribe(); } - [Fact] + [TestMethod] public void Subscribe_None_Throw() { var ex = new Exception(); @@ -212,13 +215,13 @@ public void Subscribe_None_Throw() ReactiveAssert.Throws(ex, () => xs.Subscribe()); } - [Fact] + [TestMethod] public void Subscribe_None_Empty() { Observable.Empty(Scheduler.Immediate).Subscribe((int _) => { Assert.True(false); }); } - [Fact] + [TestMethod] public void Subscribe_OnNext_Return() { var _x = -1; @@ -226,7 +229,7 @@ public void Subscribe_OnNext_Return() Assert.Equal(42, _x); } - [Fact] + [TestMethod] public void Subscribe_OnNext_Throw() { var ex = new Exception(); @@ -236,13 +239,13 @@ public void Subscribe_OnNext_Throw() ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.True(false); })); } - [Fact] + [TestMethod] public void Subscribe_OnNext_Empty() { Observable.Empty(Scheduler.Immediate).Subscribe((int _) => { Assert.True(false); }); } - [Fact] + [TestMethod] public void Subscribe_OnNextOnCompleted_Return() { var finished = false; @@ -252,7 +255,7 @@ public void Subscribe_OnNextOnCompleted_Return() Assert.True(finished); } - [Fact] + [TestMethod] public void Subscribe_OnNextOnCompleted_Throw() { var ex = new Exception(); @@ -262,7 +265,7 @@ public void Subscribe_OnNextOnCompleted_Throw() ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.True(false); }, () => { Assert.True(false); })); } - [Fact] + [TestMethod] public void Subscribe_OnNextOnCompleted_Empty() { var finished = false; @@ -274,7 +277,7 @@ public void Subscribe_OnNextOnCompleted_Empty() #region Subscribe with CancellationToken - [Fact] + [TestMethod] public void Subscribe_CT_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -303,7 +306,7 @@ public void Subscribe_CT_ArgumentChecking() ReactiveAssert.Throws(() => ObservableExtensions.Subscribe(someObservable, _ => { }, (Exception _) => { }, default, ct)); } - [Fact] + [TestMethod] public void Subscribe_CT_None() { var scheduler = new TestScheduler(); @@ -333,7 +336,7 @@ public void Subscribe_CT_None() ); } - [Fact] + [TestMethod] public void Subscribe_CT_CancelBeforeBegin() { var scheduler = new TestScheduler(); @@ -361,7 +364,7 @@ public void Subscribe_CT_CancelBeforeBegin() ); } - [Fact] + [TestMethod] public void Subscribe_CT_CancelMiddle() { var scheduler = new TestScheduler(); @@ -392,7 +395,7 @@ public void Subscribe_CT_CancelMiddle() ); } - [Fact] + [TestMethod] public void Subscribe_CT_CancelAfterEnd() { var scheduler = new TestScheduler(); @@ -427,7 +430,7 @@ public void Subscribe_CT_CancelAfterEnd() ); } - [Fact] + [TestMethod] public void Subscribe_CT_NeverCancel() { var scheduler = new TestScheduler(); @@ -459,7 +462,7 @@ public void Subscribe_CT_NeverCancel() ); } - [Fact] + [TestMethod] public void Subscribe_CT_Overloads_AlreadyCancelled() { var xs = Observable.Defer(() => @@ -479,7 +482,7 @@ public void Subscribe_CT_Overloads_AlreadyCancelled() xs.Subscribe(Observer.Create(_ => { }, ex => { }, () => { }), cts.Token); } - [Fact] + [TestMethod] public void Subscribe_CT_Overloads_None() { var i = 0; @@ -506,7 +509,7 @@ public void Subscribe_CT_Overloads_None() Assert.Equal(3, c); } - [Fact] + [TestMethod] public void Subscribe_CT_CancelDuringCallback() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SumTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SumTest.cs index aa430b8cbf..7583de8750 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SumTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SumTest.cs @@ -6,13 +6,14 @@ using System.Linq; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class SumTest : ReactiveTest { - [Fact] + [TestMethod] public void Sum_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Sum(default(IObservable))); @@ -49,7 +50,7 @@ public void Sum_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Sum(Observable.Empty(), default(Func))); } - [Fact] + [TestMethod] public void Sum_Int32_Empty() { var scheduler = new TestScheduler(); @@ -73,7 +74,7 @@ public void Sum_Int32_Empty() ); } - [Fact] + [TestMethod] public void Sum_Int32_Return() { var scheduler = new TestScheduler(); @@ -98,7 +99,7 @@ public void Sum_Int32_Return() ); } - [Fact] + [TestMethod] public void Sum_Int32_Some() { var scheduler = new TestScheduler(); @@ -125,7 +126,7 @@ public void Sum_Int32_Some() ); } - [Fact] + [TestMethod] public void Sum_Int32_Overflow() { var scheduler = new TestScheduler(); @@ -150,7 +151,7 @@ public void Sum_Int32_Overflow() ); } - [Fact] + [TestMethod] public void Sum_Int32_Throw() { var ex = new Exception(); @@ -175,7 +176,7 @@ public void Sum_Int32_Throw() ); } - [Fact] + [TestMethod] public void Sum_Int32_Never() { var ex = new Exception(); @@ -198,7 +199,7 @@ public void Sum_Int32_Never() ); } - [Fact] + [TestMethod] public void Sum_Int64_Empty() { var scheduler = new TestScheduler(); @@ -222,7 +223,7 @@ public void Sum_Int64_Empty() ); } - [Fact] + [TestMethod] public void Sum_Int64_Return() { var scheduler = new TestScheduler(); @@ -247,7 +248,7 @@ public void Sum_Int64_Return() ); } - [Fact] + [TestMethod] public void Sum_Int64_Some() { var scheduler = new TestScheduler(); @@ -274,7 +275,7 @@ public void Sum_Int64_Some() ); } - [Fact] + [TestMethod] public void Sum_Int64_Overflow() { var scheduler = new TestScheduler(); @@ -299,7 +300,7 @@ public void Sum_Int64_Overflow() ); } - [Fact] + [TestMethod] public void Sum_Int64_Throw() { var ex = new Exception(); @@ -324,7 +325,7 @@ public void Sum_Int64_Throw() ); } - [Fact] + [TestMethod] public void Sum_Int64_Never() { var ex = new Exception(); @@ -347,7 +348,7 @@ public void Sum_Int64_Never() ); } - [Fact] + [TestMethod] public void Sum_Float_Empty() { var scheduler = new TestScheduler(); @@ -371,7 +372,7 @@ public void Sum_Float_Empty() ); } - [Fact] + [TestMethod] public void Sum_Float_Return() { var scheduler = new TestScheduler(); @@ -396,7 +397,7 @@ public void Sum_Float_Return() ); } - [Fact] + [TestMethod] public void Sum_Float_Some() { var scheduler = new TestScheduler(); @@ -423,7 +424,7 @@ public void Sum_Float_Some() ); } - [Fact] + [TestMethod] public void Sum_Float_Throw() { var ex = new Exception(); @@ -448,7 +449,7 @@ public void Sum_Float_Throw() ); } - [Fact] + [TestMethod] public void Sum_Float_Never() { var ex = new Exception(); @@ -471,7 +472,7 @@ public void Sum_Float_Never() ); } - [Fact] + [TestMethod] public void Sum_Double_Empty() { var scheduler = new TestScheduler(); @@ -495,7 +496,7 @@ public void Sum_Double_Empty() ); } - [Fact] + [TestMethod] public void Sum_Double_Return() { var scheduler = new TestScheduler(); @@ -520,7 +521,7 @@ public void Sum_Double_Return() ); } - [Fact] + [TestMethod] public void Sum_Double_Some() { var scheduler = new TestScheduler(); @@ -547,7 +548,7 @@ public void Sum_Double_Some() ); } - [Fact] + [TestMethod] public void Sum_Double_Throw() { var ex = new Exception(); @@ -572,7 +573,7 @@ public void Sum_Double_Throw() ); } - [Fact] + [TestMethod] public void Sum_Double_Never() { var ex = new Exception(); @@ -595,7 +596,7 @@ public void Sum_Double_Never() ); } - [Fact] + [TestMethod] public void Sum_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -619,7 +620,7 @@ public void Sum_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Sum_Decimal_Return() { var scheduler = new TestScheduler(); @@ -644,7 +645,7 @@ public void Sum_Decimal_Return() ); } - [Fact] + [TestMethod] public void Sum_Decimal_Some() { var scheduler = new TestScheduler(); @@ -671,7 +672,7 @@ public void Sum_Decimal_Some() ); } - [Fact] + [TestMethod] public void Sum_Decimal_Throw() { var ex = new Exception(); @@ -696,7 +697,7 @@ public void Sum_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Sum_Decimal_Never() { var ex = new Exception(); @@ -719,7 +720,7 @@ public void Sum_Decimal_Never() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int32_Empty() { var scheduler = new TestScheduler(); @@ -743,7 +744,7 @@ public void Sum_Nullable_Int32_Empty() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int32_Return() { var scheduler = new TestScheduler(); @@ -768,7 +769,7 @@ public void Sum_Nullable_Int32_Return() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int32_Some() { var scheduler = new TestScheduler(); @@ -795,7 +796,7 @@ public void Sum_Nullable_Int32_Some() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int32_Overflow() { var scheduler = new TestScheduler(); @@ -820,7 +821,7 @@ public void Sum_Nullable_Int32_Overflow() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int32_Throw() { var ex = new Exception(); @@ -845,7 +846,7 @@ public void Sum_Nullable_Int32_Throw() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int32_Never() { var ex = new Exception(); @@ -868,7 +869,7 @@ public void Sum_Nullable_Int32_Never() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int64_Empty() { var scheduler = new TestScheduler(); @@ -892,7 +893,7 @@ public void Sum_Nullable_Int64_Empty() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int64_Return() { var scheduler = new TestScheduler(); @@ -917,7 +918,7 @@ public void Sum_Nullable_Int64_Return() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int64_Some() { var scheduler = new TestScheduler(); @@ -944,7 +945,7 @@ public void Sum_Nullable_Int64_Some() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int64_Overflow() { var scheduler = new TestScheduler(); @@ -969,7 +970,7 @@ public void Sum_Nullable_Int64_Overflow() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int64_Throw() { var ex = new Exception(); @@ -994,7 +995,7 @@ public void Sum_Nullable_Int64_Throw() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Int64_Never() { var ex = new Exception(); @@ -1017,7 +1018,7 @@ public void Sum_Nullable_Int64_Never() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Float_Empty() { var scheduler = new TestScheduler(); @@ -1041,7 +1042,7 @@ public void Sum_Nullable_Float_Empty() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Float_Return() { var scheduler = new TestScheduler(); @@ -1066,7 +1067,7 @@ public void Sum_Nullable_Float_Return() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Float_Some() { var scheduler = new TestScheduler(); @@ -1093,7 +1094,7 @@ public void Sum_Nullable_Float_Some() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Float_Throw() { var ex = new Exception(); @@ -1118,7 +1119,7 @@ public void Sum_Nullable_Float_Throw() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Float_Never() { var ex = new Exception(); @@ -1141,7 +1142,7 @@ public void Sum_Nullable_Float_Never() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Double_Empty() { var scheduler = new TestScheduler(); @@ -1165,7 +1166,7 @@ public void Sum_Nullable_Double_Empty() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Double_Return() { var scheduler = new TestScheduler(); @@ -1190,7 +1191,7 @@ public void Sum_Nullable_Double_Return() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Double_Some() { var scheduler = new TestScheduler(); @@ -1217,7 +1218,7 @@ public void Sum_Nullable_Double_Some() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Double_Throw() { var ex = new Exception(); @@ -1242,7 +1243,7 @@ public void Sum_Nullable_Double_Throw() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Double_Never() { var ex = new Exception(); @@ -1265,7 +1266,7 @@ public void Sum_Nullable_Double_Never() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Decimal_Empty() { var scheduler = new TestScheduler(); @@ -1289,7 +1290,7 @@ public void Sum_Nullable_Decimal_Empty() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Decimal_Return() { var scheduler = new TestScheduler(); @@ -1314,7 +1315,7 @@ public void Sum_Nullable_Decimal_Return() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Decimal_Some() { var scheduler = new TestScheduler(); @@ -1341,7 +1342,7 @@ public void Sum_Nullable_Decimal_Some() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Decimal_Throw() { var ex = new Exception(); @@ -1366,7 +1367,7 @@ public void Sum_Nullable_Decimal_Throw() ); } - [Fact] + [TestMethod] public void Sum_Nullable_Decimal_Never() { var ex = new Exception(); @@ -1389,7 +1390,7 @@ public void Sum_Nullable_Decimal_Never() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Int32() { var scheduler = new TestScheduler(); @@ -1413,7 +1414,7 @@ public void Sum_Selector_Regular_Int32() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Int64() { var scheduler = new TestScheduler(); @@ -1437,7 +1438,7 @@ public void Sum_Selector_Regular_Int64() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Single() { var scheduler = new TestScheduler(); @@ -1461,7 +1462,7 @@ public void Sum_Selector_Regular_Single() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Double() { var scheduler = new TestScheduler(); @@ -1485,7 +1486,7 @@ public void Sum_Selector_Regular_Double() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Decimal() { var scheduler = new TestScheduler(); @@ -1509,7 +1510,7 @@ public void Sum_Selector_Regular_Decimal() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Int32_Nullable() { var scheduler = new TestScheduler(); @@ -1533,7 +1534,7 @@ public void Sum_Selector_Regular_Int32_Nullable() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Int64_Nullable() { var scheduler = new TestScheduler(); @@ -1557,7 +1558,7 @@ public void Sum_Selector_Regular_Int64_Nullable() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Single_Nullable() { var scheduler = new TestScheduler(); @@ -1581,7 +1582,7 @@ public void Sum_Selector_Regular_Single_Nullable() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Double_Nullable() { var scheduler = new TestScheduler(); @@ -1605,7 +1606,7 @@ public void Sum_Selector_Regular_Double_Nullable() ); } - [Fact] + [TestMethod] public void Sum_Selector_Regular_Decimal_Nullable() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SwitchTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SwitchTest.cs index b10c630c43..4871c5c940 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SwitchTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SwitchTest.cs @@ -8,21 +8,24 @@ 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 { + [TestClass] public class SwitchTest : ReactiveTest { - [Fact] + [TestMethod] public void Switch_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Switch((IObservable>)null)); ReactiveAssert.Throws(() => Observable.Switch((IObservable>)null)); } - [Fact] + [TestMethod] public void Switch_Data() { var scheduler = new TestScheduler(); @@ -109,7 +112,7 @@ public void Switch_Data() ); } - [Fact] + [TestMethod] public void Switch_InnerThrows() { var scheduler = new TestScheduler(); @@ -179,7 +182,7 @@ public void Switch_InnerThrows() ); } - [Fact] + [TestMethod] public void Switch_OuterThrows() { var scheduler = new TestScheduler(); @@ -244,7 +247,7 @@ public void Switch_OuterThrows() #endif } - [Fact] + [TestMethod] public void Switch_NoInner() { var scheduler = new TestScheduler(); @@ -266,7 +269,7 @@ public void Switch_NoInner() ); } - [Fact] + [TestMethod] public void Switch_InnerCompletes() { var scheduler = new TestScheduler(); @@ -316,7 +319,7 @@ public void Switch_InnerCompletes() #endif } - [Fact] + [TestMethod] public void Switch_Task() { var tss = Observable.Switch(new[] { Task.Factory.StartNew(() => 1), Task.Factory.StartNew(() => 2), Task.Factory.StartNew(() => 3) }.ToObservable()); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SynchronizeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SynchronizeTest.cs index ba34ea9fdd..4b3a11baa0 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SynchronizeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/SynchronizeTest.cs @@ -8,13 +8,16 @@ 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 SynchronizeTest : TestBase { - [Fact] + [TestMethod] public void Synchronize_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -26,7 +29,7 @@ public void Synchronize_ArgumentChecking() } #if !NO_THREAD - [Fact] + [TestMethod] public void Synchronize_Range() { var i = 0; @@ -54,7 +57,7 @@ public void Synchronize_Range() } } - [Fact] + [TestMethod] public void Synchronize_Throw() { var ex = new Exception(); @@ -86,7 +89,7 @@ public void Synchronize_Throw() Assert.Same(ex, e); } - [Fact] + [TestMethod] public void Synchronize_BadObservable() { var o = Observable.Create(obs => diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastBufferTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastBufferTest.cs index 024237bd46..309a91aaf6 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastBufferTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastBufferTest.cs @@ -10,23 +10,26 @@ 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 TakeLastBufferTest : ReactiveTest { #region + Count + - [Fact] + [TestMethod] public void TakeLastBuffer_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.TakeLastBuffer(null, 0)); ReactiveAssert.Throws(() => Observable.TakeLastBuffer(DummyObservable.Instance, -1)); } - [Fact] + [TestMethod] public void TakeLastBuffer_Zero_Completed() { var scheduler = new TestScheduler(); @@ -58,7 +61,7 @@ public void TakeLastBuffer_Zero_Completed() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Zero_Error() { var scheduler = new TestScheduler(); @@ -91,7 +94,7 @@ public void TakeLastBuffer_Zero_Error() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Zero_Disposed() { var scheduler = new TestScheduler(); @@ -120,7 +123,7 @@ public void TakeLastBuffer_Zero_Disposed() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_One_Completed() { var scheduler = new TestScheduler(); @@ -152,7 +155,7 @@ public void TakeLastBuffer_One_Completed() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_One_Error() { var scheduler = new TestScheduler(); @@ -185,7 +188,7 @@ public void TakeLastBuffer_One_Error() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_One_Disposed() { var scheduler = new TestScheduler(); @@ -214,7 +217,7 @@ public void TakeLastBuffer_One_Disposed() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Three_Completed() { var scheduler = new TestScheduler(); @@ -246,7 +249,7 @@ public void TakeLastBuffer_Three_Completed() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Three_Error() { var scheduler = new TestScheduler(); @@ -279,7 +282,7 @@ public void TakeLastBuffer_Three_Error() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Three_Disposed() { var scheduler = new TestScheduler(); @@ -312,7 +315,7 @@ public void TakeLastBuffer_Three_Disposed() #region + Timed + - [Fact] + [TestMethod] public void TakeLastBuffer_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -325,7 +328,7 @@ public void TakeLastBuffer_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.TakeLastBuffer(xs, TimeSpan.FromSeconds(-1), Scheduler.Default)); } - [Fact] + [TestMethod] public void TakeLastBuffer_Zero1() { var scheduler = new TestScheduler(); @@ -350,7 +353,7 @@ public void TakeLastBuffer_Zero1() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Zero2() { var scheduler = new TestScheduler(); @@ -376,7 +379,7 @@ public void TakeLastBuffer_Zero2() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Some1() { var scheduler = new TestScheduler(); @@ -402,7 +405,7 @@ public void TakeLastBuffer_Some1() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Some2() { var scheduler = new TestScheduler(); @@ -428,7 +431,7 @@ public void TakeLastBuffer_Some2() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Some3() { var scheduler = new TestScheduler(); @@ -460,7 +463,7 @@ public void TakeLastBuffer_Some3() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Some4() { var scheduler = new TestScheduler(); @@ -489,7 +492,7 @@ public void TakeLastBuffer_Some4() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_All() { var scheduler = new TestScheduler(); @@ -514,7 +517,7 @@ public void TakeLastBuffer_All() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Error() { var scheduler = new TestScheduler(); @@ -538,7 +541,7 @@ public void TakeLastBuffer_Error() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Never() { var scheduler = new TestScheduler(); @@ -560,7 +563,7 @@ public void TakeLastBuffer_Never() ); } - [Fact] + [TestMethod] public void TakeLastBuffer_Default1() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -580,7 +583,7 @@ public void TakeLastBuffer_Default1() Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void TakeLastBuffer_Default2() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -600,7 +603,7 @@ public void TakeLastBuffer_Default2() Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void TakeLastBuffer_Default3() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -620,7 +623,7 @@ public void TakeLastBuffer_Default3() Assert.True(lst.Count == 0); } - [Fact] + [TestMethod] public void TakeLastBuffer_Default4() { var xs = Observable.Range(0, 10, Scheduler.Default); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastTest.cs index bff08c5c86..9f7f587c32 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeLastTest.cs @@ -10,16 +10,19 @@ 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 TakeLastTest : ReactiveTest { #region + Count + - [Fact] + [TestMethod] public void TakeLast_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.TakeLast(null, 0)); @@ -29,7 +32,7 @@ public void TakeLast_ArgumentChecking() ReactiveAssert.Throws(() => Observable.TakeLast(DummyObservable.Instance, 0, default)); } - [Fact] + [TestMethod] public void TakeLast_Zero_Completed() { var scheduler = new TestScheduler(); @@ -60,7 +63,7 @@ public void TakeLast_Zero_Completed() ); } - [Fact] + [TestMethod] public void TakeLast_Zero_Error() { var scheduler = new TestScheduler(); @@ -93,7 +96,7 @@ public void TakeLast_Zero_Error() ); } - [Fact] + [TestMethod] public void TakeLast_Zero_Disposed() { var scheduler = new TestScheduler(); @@ -122,7 +125,7 @@ public void TakeLast_Zero_Disposed() ); } - [Fact] + [TestMethod] public void TakeLast_One_Completed() { var scheduler = new TestScheduler(); @@ -154,7 +157,7 @@ public void TakeLast_One_Completed() ); } - [Fact] + [TestMethod] public void TakeLast_One_Error() { var scheduler = new TestScheduler(); @@ -187,7 +190,7 @@ public void TakeLast_One_Error() ); } - [Fact] + [TestMethod] public void TakeLast_One_Disposed() { var scheduler = new TestScheduler(); @@ -216,7 +219,7 @@ public void TakeLast_One_Disposed() ); } - [Fact] + [TestMethod] public void TakeLast_Three_Completed() { var scheduler = new TestScheduler(); @@ -250,7 +253,7 @@ public void TakeLast_Three_Completed() ); } - [Fact] + [TestMethod] public void TakeLast_Three_Error() { var scheduler = new TestScheduler(); @@ -283,7 +286,7 @@ public void TakeLast_Three_Error() ); } - [Fact] + [TestMethod] public void TakeLast_Three_Disposed() { var scheduler = new TestScheduler(); @@ -312,7 +315,7 @@ public void TakeLast_Three_Disposed() ); } - [Fact] + [TestMethod] public void TakeLast_LongRunning_Regular() { var res = Observable.Range(0, 100, Scheduler.Default).TakeLast(10, NewThreadScheduler.Default); @@ -327,7 +330,7 @@ public void TakeLast_LongRunning_Regular() #region + Timed + - [Fact] + [TestMethod] public void TakeLast_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -345,7 +348,7 @@ public void TakeLast_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.TakeLast(xs, TimeSpan.FromSeconds(-1), Scheduler.Default, Scheduler.Default)); } - [Fact] + [TestMethod] public void TakeLast_Zero1() { var scheduler = new TestScheduler(); @@ -369,7 +372,7 @@ public void TakeLast_Zero1() ); } - [Fact] + [TestMethod] public void TakeLast_Zero1_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -393,7 +396,7 @@ public void TakeLast_Zero1_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Zero2() { var scheduler = new TestScheduler(); @@ -418,7 +421,7 @@ public void TakeLast_Zero2() ); } - [Fact] + [TestMethod] public void TakeLast_Zero2_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -443,7 +446,7 @@ public void TakeLast_Zero2_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Some1() { var scheduler = new TestScheduler(); @@ -470,7 +473,7 @@ public void TakeLast_Some1() ); } - [Fact] + [TestMethod] public void TakeLast_Some1_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -497,7 +500,7 @@ public void TakeLast_Some1_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Some2() { var scheduler = new TestScheduler(); @@ -522,7 +525,7 @@ public void TakeLast_Some2() ); } - [Fact] + [TestMethod] public void TakeLast_Some2_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -547,7 +550,7 @@ public void TakeLast_Some2_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Some3() { var scheduler = new TestScheduler(); @@ -582,7 +585,7 @@ public void TakeLast_Some3() ); } - [Fact] + [TestMethod] public void TakeLast_Some3_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -617,7 +620,7 @@ public void TakeLast_Some3_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Some4() { var scheduler = new TestScheduler(); @@ -645,7 +648,7 @@ public void TakeLast_Some4() ); } - [Fact] + [TestMethod] public void TakeLast_Some4_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -673,7 +676,7 @@ public void TakeLast_Some4_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_All() { var scheduler = new TestScheduler(); @@ -699,7 +702,7 @@ public void TakeLast_All() ); } - [Fact] + [TestMethod] public void TakeLast_All_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -725,7 +728,7 @@ public void TakeLast_All_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Error() { var scheduler = new TestScheduler(); @@ -749,7 +752,7 @@ public void TakeLast_Error() ); } - [Fact] + [TestMethod] public void TakeLast_Error_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -773,7 +776,7 @@ public void TakeLast_Error_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Never() { var scheduler = new TestScheduler(); @@ -795,7 +798,7 @@ public void TakeLast_Never() ); } - [Fact] + [TestMethod] public void TakeLast_Never_WithLoopScheduler() { var scheduler = new TestScheduler(); @@ -817,7 +820,7 @@ public void TakeLast_Never_WithLoopScheduler() ); } - [Fact] + [TestMethod] public void TakeLast_Default1() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -837,7 +840,7 @@ public void TakeLast_Default1() Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void TakeLast_Default2() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -857,7 +860,7 @@ public void TakeLast_Default2() Assert.True(lst.SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void TakeLast_Default3() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -877,7 +880,7 @@ public void TakeLast_Default3() Assert.True(lst.Count == 0); } - [Fact] + [TestMethod] public void TakeLast_Default4() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -897,7 +900,7 @@ public void TakeLast_Default4() Assert.True(lst.Count == 0); } - [Fact] + [TestMethod] public void TakeLast_Timed_LongRunning_Regular() { var res = Observable.Range(0, 10, Scheduler.Default).TakeLast(TimeSpan.FromSeconds(60), Scheduler.Default, NewThreadScheduler.Default); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeTest.cs index 1e76055f76..2cf51421d9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeTest.cs @@ -11,15 +11,18 @@ 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 TakeTest : ReactiveTest { #region + Count + - [Fact] + [TestMethod] public void Take_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).Take(0)); @@ -31,7 +34,7 @@ public void Take_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Take(-1, Scheduler.Immediate)); } - [Fact] + [TestMethod] public void Take_Complete_After() { var scheduler = new TestScheduler(); @@ -89,7 +92,7 @@ public void Take_Complete_After() ); } - [Fact] + [TestMethod] public void Take_Complete_Same() { var scheduler = new TestScheduler(); @@ -147,7 +150,7 @@ public void Take_Complete_Same() ); } - [Fact] + [TestMethod] public void Take_Complete_Before() { var scheduler = new TestScheduler(); @@ -198,7 +201,7 @@ public void Take_Complete_Before() ); } - [Fact] + [TestMethod] public void Take_Error_After() { var scheduler = new TestScheduler(); @@ -258,7 +261,7 @@ public void Take_Error_After() ); } - [Fact] + [TestMethod] public void Take_Error_Same() { var scheduler = new TestScheduler(); @@ -316,7 +319,7 @@ public void Take_Error_Same() ); } - [Fact] + [TestMethod] public void Take_Error_Before() { var scheduler = new TestScheduler(); @@ -360,7 +363,7 @@ public void Take_Error_Before() ); } - [Fact] + [TestMethod] public void Take_Dispose_Before() { var scheduler = new TestScheduler(); @@ -402,7 +405,7 @@ public void Take_Dispose_Before() ); } - [Fact] + [TestMethod] public void Take_Dispose_After() { var scheduler = new TestScheduler(); @@ -446,7 +449,7 @@ public void Take_Dispose_After() ); } - [Fact] + [TestMethod] public void Take_0_Scheduler() { var scheduler = new TestScheduler(); @@ -470,7 +473,7 @@ public void Take_0_Scheduler() ); } - [Fact] + [TestMethod] public void Take_0_DefaultScheduler() { var scheduler = new TestScheduler(); @@ -494,7 +497,7 @@ public void Take_0_DefaultScheduler() ); } - [Fact] + [TestMethod] public void Take_Non0_Scheduler() { var scheduler = new TestScheduler(); @@ -520,7 +523,7 @@ public void Take_Non0_Scheduler() ); } - [Fact] + [TestMethod] public void Take_Take1() { var scheduler = new TestScheduler(); @@ -555,7 +558,7 @@ public void Take_Take1() ); } - [Fact] + [TestMethod] public void Take_Take2() { var scheduler = new TestScheduler(); @@ -590,7 +593,7 @@ public void Take_Take2() ); } - [Fact] + [TestMethod] public void Take_DecrementsCountFirst() { var k = new BehaviorSubject(true); @@ -605,7 +608,7 @@ public void Take_DecrementsCountFirst() #region + Timed + - [Fact] + [TestMethod] public void Take_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -618,7 +621,7 @@ public void Take_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Take(xs, TimeSpan.FromSeconds(-1), Scheduler.Default)); } - [Fact] + [TestMethod] public void Take_Zero() { var scheduler = new TestScheduler(); @@ -642,7 +645,7 @@ public void Take_Zero() ); } - [Fact] + [TestMethod] public void Take_Some() { var scheduler = new TestScheduler(); @@ -669,7 +672,7 @@ public void Take_Some() ); } - [Fact] + [TestMethod] public void Take_Late() { var scheduler = new TestScheduler(); @@ -695,7 +698,7 @@ public void Take_Late() ); } - [Fact] + [TestMethod] public void Take_Error() { var scheduler = new TestScheduler(); @@ -719,7 +722,7 @@ public void Take_Error() ); } - [Fact] + [TestMethod] public void Take_Never() { var scheduler = new TestScheduler(); @@ -742,7 +745,7 @@ public void Take_Never() ); } - [Fact] + [TestMethod] public void Take_Twice1() { var scheduler = new TestScheduler(); @@ -775,7 +778,7 @@ public void Take_Twice1() ); } - [Fact] + [TestMethod] public void Take_Twice2() { var scheduler = new TestScheduler(); @@ -808,7 +811,7 @@ public void Take_Twice2() ); } - [Fact] + [TestMethod] public void Take_Default() { var xs = Observable.Range(0, 10, Scheduler.Default); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs index b5056e622f..c55ebd2f0f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeUntilTest.cs @@ -10,22 +10,25 @@ 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 TakeUntilTest : ReactiveTest { #region + Observable + - [Fact] + [TestMethod] public void TakeUntil_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.TakeUntil(null, DummyObservable.Instance)); ReactiveAssert.Throws(() => Observable.TakeUntil(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void TakeUntil_Preempt_SomeData_Next() { var scheduler = new TestScheduler(); @@ -64,7 +67,7 @@ public void TakeUntil_Preempt_SomeData_Next() ); } - [Fact] + [TestMethod] public void TakeUntil_Preempt_SomeData_Error() { var scheduler = new TestScheduler(); @@ -104,7 +107,7 @@ public void TakeUntil_Preempt_SomeData_Error() ); } - [Fact] + [TestMethod] public void TakeUntil_NoPreempt_SomeData_Empty() { var scheduler = new TestScheduler(); @@ -144,7 +147,7 @@ public void TakeUntil_NoPreempt_SomeData_Empty() ); } - [Fact] + [TestMethod] public void TakeUntil_NoPreempt_SomeData_Never() { var scheduler = new TestScheduler(); @@ -183,7 +186,7 @@ public void TakeUntil_NoPreempt_SomeData_Never() ); } - [Fact] + [TestMethod] public void TakeUntil_Preempt_Never_Next() { var scheduler = new TestScheduler(); @@ -215,7 +218,7 @@ public void TakeUntil_Preempt_Never_Next() ); } - [Fact] + [TestMethod] public void TakeUntil_Preempt_Never_Error() { var scheduler = new TestScheduler(); @@ -248,7 +251,7 @@ public void TakeUntil_Preempt_Never_Error() ); } - [Fact] + [TestMethod] public void TakeUntil_NoPreempt_Never_Empty() { var scheduler = new TestScheduler(); @@ -278,7 +281,7 @@ public void TakeUntil_NoPreempt_Never_Empty() ); } - [Fact] + [TestMethod] public void TakeUntil_NoPreempt_Never_Never() { var scheduler = new TestScheduler(); @@ -307,7 +310,7 @@ public void TakeUntil_NoPreempt_Never_Never() ); } - [Fact] + [TestMethod] public void TakeUntil_Preempt_BeforeFirstProduced() { var scheduler = new TestScheduler(); @@ -341,7 +344,7 @@ public void TakeUntil_Preempt_BeforeFirstProduced() ); } - [Fact] + [TestMethod] public void TakeUntil_Preempt_BeforeFirstProduced_RemainSilentAndProperDisposed() { var scheduler = new TestScheduler(); @@ -371,7 +374,7 @@ public void TakeUntil_Preempt_BeforeFirstProduced_RemainSilentAndProperDisposed( Assert.False(sourceNotDisposed); } - [Fact] + [TestMethod] public void TakeUntil_NoPreempt_AfterLastProduced_ProperDisposedSignal() { var scheduler = new TestScheduler(); @@ -402,7 +405,7 @@ public void TakeUntil_NoPreempt_AfterLastProduced_ProperDisposedSignal() Assert.False(signalNotDisposed); } - [Fact] + [TestMethod] public void TakeUntil_Error_Some() { var scheduler = new TestScheduler(); @@ -436,7 +439,7 @@ public void TakeUntil_Error_Some() ); } - [Fact] + [TestMethod] public void TakeUntil_Immediate() { var scheduler = new TestScheduler(); @@ -456,7 +459,7 @@ public void TakeUntil_Immediate() #region + Timed + - [Fact] + [TestMethod] public void TakeUntil_Timed_ArgumentChecking() { var xs = Observable.Return(42); @@ -467,7 +470,7 @@ public void TakeUntil_Timed_ArgumentChecking() ReactiveAssert.Throws(() => Observable.TakeUntil(xs, DateTimeOffset.Now, default)); } - [Fact] + [TestMethod] public void TakeUntil_Zero() { var scheduler = new TestScheduler(); @@ -491,7 +494,7 @@ public void TakeUntil_Zero() ); } - [Fact] + [TestMethod] public void TakeUntil_Some() { var scheduler = new TestScheduler(); @@ -518,7 +521,7 @@ public void TakeUntil_Some() ); } - [Fact] + [TestMethod] public void TakeUntil_Late() { var scheduler = new TestScheduler(); @@ -544,7 +547,7 @@ public void TakeUntil_Late() ); } - [Fact] + [TestMethod] public void TakeUntil_Error() { var scheduler = new TestScheduler(); @@ -568,7 +571,7 @@ public void TakeUntil_Error() ); } - [Fact] + [TestMethod] public void TakeUntil_Never() { var scheduler = new TestScheduler(); @@ -591,7 +594,7 @@ public void TakeUntil_Never() ); } - [Fact] + [TestMethod] public void TakeUntil_Twice1() { var scheduler = new TestScheduler(); @@ -624,7 +627,7 @@ public void TakeUntil_Twice1() ); } - [Fact] + [TestMethod] public void TakeUntil_Twice2() { var scheduler = new TestScheduler(); @@ -657,7 +660,7 @@ public void TakeUntil_Twice2() ); } - [Fact] + [TestMethod] public void TakeUntil_Default() { var xs = Observable.Range(0, 10, Scheduler.Default); @@ -681,14 +684,14 @@ public void TakeUntil_Default() #region + Predicate + - [Fact] + [TestMethod] public void TakeUntil_Predicate_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.TakeUntil(null, v => true)); ReactiveAssert.Throws(() => Observable.TakeUntil(DummyObservable.Instance, null)); } - [Fact] + [TestMethod] public void TakeUntil_Predicate_Basic() { var scheduler = new TestScheduler(); @@ -722,7 +725,7 @@ public void TakeUntil_Predicate_Basic() ); } - [Fact] + [TestMethod] public void TakeUntil_Predicate_True() { var scheduler = new TestScheduler(); @@ -752,7 +755,7 @@ public void TakeUntil_Predicate_True() ); } - [Fact] + [TestMethod] public void TakeUntil_Predicate_False() { var scheduler = new TestScheduler(); @@ -790,7 +793,7 @@ public void TakeUntil_Predicate_False() ); } - [Fact] + [TestMethod] public void TakeUntil_Predicate_Error() { var scheduler = new TestScheduler(); @@ -818,7 +821,7 @@ public void TakeUntil_Predicate_Error() ); } - [Fact] + [TestMethod] public void TakeUntil_Predicate_Crash() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeWhileTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeWhileTest.cs index 33c8ce91c0..b106bc1679 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeWhileTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TakeWhileTest.cs @@ -7,14 +7,17 @@ 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 TakeWhileTest : ReactiveTest { - [Fact] + [TestMethod] public void TakeWhile_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).TakeWhile(DummyFunc.Instance)); @@ -24,7 +27,7 @@ public void TakeWhile_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.TakeWhile(default(Func))); } - [Fact] + [TestMethod] public void TakeWhile_Complete_Before() { var scheduler = new TestScheduler(); @@ -70,7 +73,7 @@ public void TakeWhile_Complete_Before() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Complete_After() { var scheduler = new TestScheduler(); @@ -116,7 +119,7 @@ public void TakeWhile_Complete_After() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Error_Before() { var scheduler = new TestScheduler(); @@ -161,7 +164,7 @@ public void TakeWhile_Error_Before() Assert.Equal(2, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Error_After() { var scheduler = new TestScheduler(); @@ -207,7 +210,7 @@ public void TakeWhile_Error_After() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Dispose_Before() { var scheduler = new TestScheduler(); @@ -251,7 +254,7 @@ public void TakeWhile_Dispose_Before() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Dispose_After() { var scheduler = new TestScheduler(); @@ -298,7 +301,7 @@ public void TakeWhile_Dispose_After() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Zero() { var scheduler = new TestScheduler(); @@ -341,7 +344,7 @@ public void TakeWhile_Zero() Assert.Equal(1, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Throw() { var scheduler = new TestScheduler(); @@ -390,7 +393,7 @@ public void TakeWhile_Throw() Assert.Equal(3, invoked); } - [Fact] + [TestMethod] public void TakeWhile_Index1() { var scheduler = new TestScheduler(); @@ -429,7 +432,7 @@ public void TakeWhile_Index1() ); } - [Fact] + [TestMethod] public void TakeWhile_Index2() { var scheduler = new TestScheduler(); @@ -467,7 +470,7 @@ public void TakeWhile_Index2() ); } - [Fact] + [TestMethod] public void TakeWhile_Index_Throw() { var scheduler = new TestScheduler(); @@ -507,7 +510,7 @@ public void TakeWhile_Index_Throw() ); } - [Fact] + [TestMethod] public void TakeWhile_Index_SelectorThrows() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThenTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThenTest.cs index b24c895431..42949332a8 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThenTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThenTest.cs @@ -6,14 +6,15 @@ 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 ThenTest : ReactiveTest { - [Fact] + [TestMethod] public void Then_ArgumentChecking() { var someObservable = Observable.Return(1); @@ -37,7 +38,7 @@ public void Then_ArgumentChecking() ReactiveAssert.Throws(() => 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(someObservable).Then(null)); } - [Fact] + [TestMethod] public void Then1() { var scheduler = new TestScheduler(); @@ -57,7 +58,7 @@ public void Then1() ); } - [Fact] + [TestMethod] public void Then1Error() { var ex = new Exception(); @@ -77,7 +78,7 @@ public void Then1Error() ); } - [Fact] + [TestMethod] public void Then1Throws() { var ex = new Exception(); @@ -98,7 +99,7 @@ public void Then1Throws() ); } - [Fact] + [TestMethod] public void Then2Throws() { var scheduler = new TestScheduler(); @@ -124,7 +125,7 @@ public void Then2Throws() ); } - [Fact] + [TestMethod] public void Then3Throws() { var scheduler = new TestScheduler(); @@ -150,7 +151,7 @@ public void Then3Throws() ); } - [Fact] + [TestMethod] public void Then4Throws() { var scheduler = new TestScheduler(); @@ -176,7 +177,7 @@ public void Then4Throws() ); } - [Fact] + [TestMethod] public void Then5Throws() { var scheduler = new TestScheduler(); @@ -202,7 +203,7 @@ public void Then5Throws() ); } - [Fact] + [TestMethod] public void Then6Throws() { var scheduler = new TestScheduler(); @@ -228,7 +229,7 @@ public void Then6Throws() ); } - [Fact] + [TestMethod] public void Then7Throws() { var scheduler = new TestScheduler(); @@ -254,7 +255,7 @@ public void Then7Throws() ); } - [Fact] + [TestMethod] public void Then8Throws() { var scheduler = new TestScheduler(); @@ -280,7 +281,7 @@ public void Then8Throws() ); } - [Fact] + [TestMethod] public void Then9Throws() { var scheduler = new TestScheduler(); @@ -306,7 +307,7 @@ public void Then9Throws() ); } - [Fact] + [TestMethod] public void Then10Throws() { var scheduler = new TestScheduler(); @@ -332,7 +333,7 @@ public void Then10Throws() ); } - [Fact] + [TestMethod] public void Then11Throws() { var scheduler = new TestScheduler(); @@ -358,7 +359,7 @@ public void Then11Throws() ); } - [Fact] + [TestMethod] public void Then12Throws() { var scheduler = new TestScheduler(); @@ -384,7 +385,7 @@ public void Then12Throws() ); } - [Fact] + [TestMethod] public void Then13Throws() { var scheduler = new TestScheduler(); @@ -410,7 +411,7 @@ public void Then13Throws() ); } - [Fact] + [TestMethod] public void Then14Throws() { var scheduler = new TestScheduler(); @@ -436,7 +437,7 @@ public void Then14Throws() ); } - [Fact] + [TestMethod] public void Then15Throws() { var scheduler = new TestScheduler(); @@ -462,7 +463,7 @@ public void Then15Throws() ); } - [Fact] + [TestMethod] public void Then16Throws() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrottleTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrottleTest.cs index a1805b11f1..3ad3e90607 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrottleTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrottleTest.cs @@ -9,14 +9,17 @@ 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 ThrottleTest : ReactiveTest { - [Fact] + [TestMethod] public void Throttle_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -41,7 +44,7 @@ private IEnumerable>> Generate(S seed, Func.Instance; @@ -282,7 +285,7 @@ public void Throttle_Duration_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Throttle(someObservable, default(Func>))); } - [Fact] + [TestMethod] public void Throttle_Duration_DelayBehavior() { var scheduler = new TestScheduler(); @@ -344,7 +347,7 @@ public void Throttle_Duration_DelayBehavior() ys[4].Subscriptions.AssertEqual(Subscribe(400, 400 + 20)); } - [Fact] + [TestMethod] public void Throttle_Duration_ThrottleBehavior() { var scheduler = new TestScheduler(); @@ -404,7 +407,7 @@ public void Throttle_Duration_ThrottleBehavior() ys[4].Subscriptions.AssertEqual(Subscribe(400, 400 + 20)); } - [Fact] + [TestMethod] public void Throttle_Duration_EarlyCompletion() { var scheduler = new TestScheduler(); @@ -464,7 +467,7 @@ public void Throttle_Duration_EarlyCompletion() ys[4].Subscriptions.AssertEqual(Subscribe(400, 410)); } - [Fact] + [TestMethod] public void Throttle_Duration_InnerError() { var scheduler = new TestScheduler(); @@ -502,7 +505,7 @@ public void Throttle_Duration_InnerError() ); } - [Fact] + [TestMethod] public void Throttle_Duration_OuterError() { var scheduler = new TestScheduler(); @@ -537,7 +540,7 @@ public void Throttle_Duration_OuterError() ); } - [Fact] + [TestMethod] public void Throttle_Duration_SelectorThrows() { var scheduler = new TestScheduler(); @@ -580,7 +583,7 @@ public void Throttle_Duration_SelectorThrows() ); } - [Fact] + [TestMethod] public void Throttle_Duration_InnerDone_DelayBehavior() { var scheduler = new TestScheduler(); @@ -615,7 +618,7 @@ public void Throttle_Duration_InnerDone_DelayBehavior() ); } - [Fact] + [TestMethod] public void Throttle_Duration_InnerDone_ThrottleBehavior() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrowTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrowTest.cs index 056481f80d..1000efd72f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrowTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ThrowTest.cs @@ -8,14 +8,17 @@ 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 ThrowTest : ReactiveTest { - [Fact] + [TestMethod] public void Throw_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Throw(null)); @@ -27,7 +30,7 @@ public void Throw_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Throw(new Exception(), DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Throw_Basic() { var scheduler = new TestScheduler(); @@ -43,7 +46,7 @@ public void Throw_Basic() ); } - [Fact] + [TestMethod] public void Throw_Disposed() { var scheduler = new TestScheduler(); @@ -57,7 +60,7 @@ public void Throw_Disposed() ); } - [Fact] + [TestMethod] public void Throw_ObserverThrows() { var scheduler1 = new TestScheduler(); @@ -69,14 +72,14 @@ public void Throw_ObserverThrows() ReactiveAssert.Throws(() => scheduler1.Start()); } - [Fact] + [TestMethod] public void Throw_DefaultScheduler() { var ex = new Exception(); Observable.Throw(ex).AssertEqual(Observable.Throw(ex, DefaultScheduler.Instance)); } - [Fact] + [TestMethod] public void Throw_Witness_Basic1() { var scheduler = new TestScheduler(); @@ -92,7 +95,7 @@ public void Throw_Witness_Basic1() ); } - [Fact] + [TestMethod] public void Throw_Witness_Basic2() { var e = new ManualResetEvent(false); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeIntervalTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeIntervalTest.cs index 328ca5310d..86adeba061 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeIntervalTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeIntervalTest.cs @@ -8,14 +8,17 @@ 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 TimeIntervalTest : ReactiveTest { - [Fact] + [TestMethod] public void TimeInterval_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -26,7 +29,7 @@ public void TimeInterval_ArgumentChecking() ReactiveAssert.Throws(() => Observable.TimeInterval(someObservable, null)); } - [Fact] + [TestMethod] public void TimeInterval_Regular() { var scheduler = new TestScheduler(); @@ -59,7 +62,7 @@ public void TimeInterval_Regular() ); } - [Fact] + [TestMethod] public void TimeInterval_Empty() { var scheduler = new TestScheduler(); @@ -82,7 +85,7 @@ public void TimeInterval_Empty() ); } - [Fact] + [TestMethod] public void TimeInterval_Error() { var scheduler = new TestScheduler(); @@ -107,7 +110,7 @@ public void TimeInterval_Error() ); } - [Fact] + [TestMethod] public void TimeInterval_Never() { var scheduler = new TestScheduler(); @@ -128,13 +131,13 @@ public void TimeInterval_Never() ); } - [Fact] + [TestMethod] public void TimeInterval_DefaultScheduler() { Assert.True(Observable.Return(1).TimeInterval().Count().First() == 1); } - [Fact] + [TestMethod] public void TimeInterval_WithStopwatch_Regular() { var scheduler = new TestScheduler(); @@ -167,7 +170,7 @@ public void TimeInterval_WithStopwatch_Regular() ); } - [Fact] + [TestMethod] public void TimeInterval_WithStopwatch_Empty() { var scheduler = new TestScheduler(); @@ -190,7 +193,7 @@ public void TimeInterval_WithStopwatch_Empty() ); } - [Fact] + [TestMethod] public void TimeInterval_WithStopwatch_Error() { var scheduler = new TestScheduler(); @@ -215,7 +218,7 @@ public void TimeInterval_WithStopwatch_Error() ); } - [Fact] + [TestMethod] public void TimeInterval_WithStopwatch_Never() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeoutTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeoutTest.cs index efa22a12b9..6be0f18699 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeoutTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimeoutTest.cs @@ -7,14 +7,17 @@ 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 TimeoutTest : ReactiveTest { - [Fact] + [TestMethod] public void Timeout_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -43,7 +46,7 @@ public void Timeout_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Timeout(someObservable, TimeSpan.FromSeconds(-1), someObservable, scheduler)); } - [Fact] + [TestMethod] public void Timeout_InTime() { var scheduler = new TestScheduler(); @@ -76,7 +79,7 @@ public void Timeout_InTime() ); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_TimeoutOccurs_WithDefaultException() { var scheduler = new TestScheduler(); @@ -98,7 +101,7 @@ public void Timeout_DateTimeOffset_TimeoutOccurs_WithDefaultException() ); } - [Fact] + [TestMethod] public void Timeout_TimeSpan_TimeoutOccurs_WithDefaultException() { var scheduler = new TestScheduler(); @@ -120,31 +123,31 @@ public void Timeout_TimeSpan_TimeoutOccurs_WithDefaultException() ); } - [Fact] + [TestMethod] public void Timeout_TimeSpan_DefaultScheduler() { Assert.True(Observable.Return(1).Timeout(TimeSpan.FromSeconds(10)).ToEnumerable().Single() == 1); } - [Fact] + [TestMethod] public void Timeout_TimeSpan_Observable_DefaultScheduler() { Assert.True(Observable.Return(1).Timeout(TimeSpan.FromSeconds(10), Observable.Return(2)).ToEnumerable().Single() == 1); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_DefaultScheduler() { Assert.True(Observable.Return(1).Timeout(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(10)).ToEnumerable().Single() == 1); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_Observable_DefaultScheduler() { Assert.True(Observable.Return(1).Timeout(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(10), Observable.Return(2)).ToEnumerable().Single() == 1); } - [Fact] + [TestMethod] public void Timeout_TimeoutOccurs_1() { var scheduler = new TestScheduler(); @@ -184,7 +187,7 @@ public void Timeout_TimeoutOccurs_1() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutOccurs_2() { var scheduler = new TestScheduler(); @@ -227,7 +230,7 @@ public void Timeout_TimeoutOccurs_2() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutOccurs_Never() { var scheduler = new TestScheduler(); @@ -262,7 +265,7 @@ public void Timeout_TimeoutOccurs_Never() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutOccurs_Completed() { var scheduler = new TestScheduler(); @@ -292,7 +295,7 @@ public void Timeout_TimeoutOccurs_Completed() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutOccurs_Error() { var scheduler = new TestScheduler(); @@ -322,7 +325,7 @@ public void Timeout_TimeoutOccurs_Error() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutOccurs_NextIsError() { var ex = new Exception(); @@ -354,7 +357,7 @@ public void Timeout_TimeoutOccurs_NextIsError() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutNotOccurs_Completed() { var scheduler = new TestScheduler(); @@ -383,7 +386,7 @@ public void Timeout_TimeoutNotOccurs_Completed() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutNotOccurs_Error() { var scheduler = new TestScheduler(); @@ -414,7 +417,7 @@ public void Timeout_TimeoutNotOccurs_Error() ); } - [Fact] + [TestMethod] public void Timeout_TimeoutDoesNotOccur() { var scheduler = new TestScheduler(); @@ -454,7 +457,7 @@ public void Timeout_TimeoutDoesNotOccur() ); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_TimeoutOccurs() { var scheduler = new TestScheduler(); @@ -484,7 +487,7 @@ public void Timeout_DateTimeOffset_TimeoutOccurs() ); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_TimeoutDoesNotOccur_Completed() { var scheduler = new TestScheduler(); @@ -515,7 +518,7 @@ public void Timeout_DateTimeOffset_TimeoutDoesNotOccur_Completed() ); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_TimeoutDoesNotOccur_Error() { var scheduler = new TestScheduler(); @@ -548,7 +551,7 @@ public void Timeout_DateTimeOffset_TimeoutDoesNotOccur_Error() ); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_TimeoutOccur_2() { var scheduler = new TestScheduler(); @@ -583,7 +586,7 @@ public void Timeout_DateTimeOffset_TimeoutOccur_2() ); } - [Fact] + [TestMethod] public void Timeout_DateTimeOffset_TimeoutOccur_3() { var scheduler = new TestScheduler(); @@ -616,7 +619,7 @@ public void Timeout_DateTimeOffset_TimeoutOccur_3() ); } - [Fact] + [TestMethod] public void Timeout_Duration_ArgumentChecking() { var someObservable = Observable.Empty(); @@ -638,7 +641,7 @@ public void Timeout_Duration_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Timeout(someObservable, default(Func>))); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_Never() { var scheduler = new TestScheduler(); @@ -676,7 +679,7 @@ public void Timeout_Duration_Simple_Never() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutFirst() { var scheduler = new TestScheduler(); @@ -715,7 +718,7 @@ public void Timeout_Duration_Simple_TimeoutFirst() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutFirst_Other() { var scheduler = new TestScheduler(); @@ -764,7 +767,7 @@ public void Timeout_Duration_Simple_TimeoutFirst_Other() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutLater() { var scheduler = new TestScheduler(); @@ -807,7 +810,7 @@ public void Timeout_Duration_Simple_TimeoutLater() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutLater_Other() { var scheduler = new TestScheduler(); @@ -860,7 +863,7 @@ public void Timeout_Duration_Simple_TimeoutLater_Other() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutLater_NoFirst() { var scheduler = new TestScheduler(); @@ -896,7 +899,7 @@ public void Timeout_Duration_Simple_TimeoutLater_NoFirst() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutLater_Other_NoFirst() { var scheduler = new TestScheduler(); @@ -942,7 +945,7 @@ public void Timeout_Duration_Simple_TimeoutLater_Other_NoFirst() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_TimeoutByCompletion() { var scheduler = new TestScheduler(); @@ -985,7 +988,7 @@ public void Timeout_Duration_Simple_TimeoutByCompletion() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_SelectorThrows() { var scheduler = new TestScheduler(); @@ -1040,7 +1043,7 @@ public void Timeout_Duration_Simple_SelectorThrows() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_InnerThrows() { var ex = new Exception(); @@ -1085,7 +1088,7 @@ public void Timeout_Duration_Simple_InnerThrows() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_FirstThrows() { var ex = new Exception(); @@ -1126,7 +1129,7 @@ public void Timeout_Duration_Simple_FirstThrows() ); } - [Fact] + [TestMethod] public void Timeout_Duration_Simple_SourceThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimerTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimerTest.cs index c92fb2e326..1e128cfdac 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimerTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimerTest.cs @@ -12,14 +12,17 @@ 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 TimerTest : ReactiveTest { - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Timer(TimeSpan.Zero, null)); @@ -34,7 +37,7 @@ public void OneShotTimer_TimeSpan_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Timer(DateTimeOffset.Now, TimeSpan.FromSeconds(-1), DummyScheduler.Instance)); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_Basic() { var scheduler = new TestScheduler(); @@ -49,7 +52,7 @@ public void OneShotTimer_TimeSpan_Basic() ); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_Zero() { var scheduler = new TestScheduler(); @@ -64,7 +67,7 @@ public void OneShotTimer_TimeSpan_Zero() ); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_Zero_DefaultScheduler() { var scheduler = new TestScheduler(); @@ -78,7 +81,7 @@ public void OneShotTimer_TimeSpan_Zero_DefaultScheduler() Assert.Equal(1, observer.Messages.Count); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_Negative() { var scheduler = new TestScheduler(); @@ -93,7 +96,7 @@ public void OneShotTimer_TimeSpan_Negative() ); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_Disposed() { var scheduler = new TestScheduler(); @@ -106,7 +109,7 @@ public void OneShotTimer_TimeSpan_Disposed() ); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_ObserverThrows() { var scheduler1 = new TestScheduler(); @@ -126,31 +129,31 @@ public void OneShotTimer_TimeSpan_ObserverThrows() ReactiveAssert.Throws(() => scheduler2.Start()); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_DefaultScheduler() { Assert.True(Observable.Timer(TimeSpan.FromMilliseconds(1)).ToEnumerable().SequenceEqual(new[] { 0L })); } - [Fact] + [TestMethod] public void OneShotTimer_DateTimeOffset_DefaultScheduler() { Assert.True(Observable.Timer(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(1)).ToEnumerable().SequenceEqual(new[] { 0L })); } - [Fact] + [TestMethod] public void OneShotTimer_TimeSpan_TimeSpan_DefaultScheduler() { Assert.True(Observable.Timer(TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(1)).ToEnumerable().Take(2).SequenceEqual(new[] { 0L, 1L })); } - [Fact] + [TestMethod] public void OneShotTimer_DateTimeOffset_TimeSpan_DefaultScheduler() { Assert.True(Observable.Timer(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(1)).ToEnumerable().Take(2).SequenceEqual(new[] { 0L, 1L })); } - [Fact] + [TestMethod] public void OneShotTimer_DateTimeOffset_Basic() { var scheduler = new TestScheduler(); @@ -165,7 +168,7 @@ public void OneShotTimer_DateTimeOffset_Basic() ); } - [Fact] + [TestMethod] public void OneShotTimer_DateTimeOffset_Zero() { var scheduler = new TestScheduler(); @@ -180,7 +183,7 @@ public void OneShotTimer_DateTimeOffset_Zero() ); } - [Fact] + [TestMethod] public void OneShotTimer_DateTimeOffset_Past() { var scheduler = new TestScheduler(); @@ -195,7 +198,7 @@ public void OneShotTimer_DateTimeOffset_Past() ); } - [Fact] + [TestMethod] public void RepeatingTimer_TimeSpan_Zero_DefaultScheduler() { var scheduler = new TestScheduler(); @@ -209,7 +212,7 @@ public void RepeatingTimer_TimeSpan_Zero_DefaultScheduler() Assert.Equal(10, observer.Messages.Count); } - [Fact] + [TestMethod] public void RepeatingTimer_DateTimeOffset_TimeSpan_Simple() { var scheduler = new TestScheduler(); @@ -228,7 +231,7 @@ public void RepeatingTimer_DateTimeOffset_TimeSpan_Simple() ); } - [Fact] + [TestMethod] public void RepeatingTimer_TimeSpan_TimeSpan_Simple() { var scheduler = new TestScheduler(); @@ -247,7 +250,7 @@ public void RepeatingTimer_TimeSpan_TimeSpan_Simple() ); } - [Fact] + [TestMethod] public void RepeatingTimer_Periodic1() { var scheduler = new PeriodicTestScheduler(); @@ -272,7 +275,7 @@ public void RepeatingTimer_Periodic1() #endif } - [Fact] + [TestMethod] public void RepeatingTimer_Periodic2() { var scheduler = new PeriodicTestScheduler(); @@ -297,7 +300,7 @@ public void RepeatingTimer_Periodic2() #endif } - [Fact] + [TestMethod] public void RepeatingTimer_UsingStopwatch_Slippage1() { var scheduler = new TestScheduler(); @@ -359,7 +362,7 @@ public void RepeatingTimer_UsingStopwatch_Slippage1() ); } - [Fact] + [TestMethod] public void RepeatingTimer_UsingStopwatch_Slippage2() { var scheduler = new TestScheduler(); @@ -420,7 +423,7 @@ public void RepeatingTimer_UsingStopwatch_Slippage2() ); } - [Fact] + [TestMethod] public void RepeatingTimer_UsingStopwatch_Slippage3_CatchUpFromLongInvokeStart() { var scheduler = new TestScheduler(); @@ -460,7 +463,7 @@ public void RepeatingTimer_UsingStopwatch_Slippage3_CatchUpFromLongInvokeStart() ); } - [Fact] + [TestMethod] public void RepeatingTimer_UsingStopwatch_Slippage3_CatchUpFromLongInvokeStart_ThrowsFirst() { var ex = new Exception(); @@ -494,7 +497,7 @@ public void RepeatingTimer_UsingStopwatch_Slippage3_CatchUpFromLongInvokeStart_T } } - [Fact] + [TestMethod] public void RepeatingTimer_UsingStopwatch_Slippage3_CatchUpFromLongInvokeStart_ThrowsBeyondFirst() { var ex = new Exception(); @@ -547,7 +550,7 @@ public void RepeatingTimer_UsingStopwatch_Slippage3_CatchUpFromLongInvokeStart_T ); } - [Fact] + [TestMethod] public void RepeatingTimer_NoStopwatch_Slippage1() { var scheduler = new TestScheduler(); @@ -609,7 +612,7 @@ public void RepeatingTimer_NoStopwatch_Slippage1() ); } - [Fact] + [TestMethod] public void RepeatingTimer_NoStopwatch_Slippage2() { var scheduler = new TestScheduler(); @@ -671,7 +674,7 @@ public void RepeatingTimer_NoStopwatch_Slippage2() } #if !NO_THREAD - [Fact] + [TestMethod] public void RepeatingTimer_Start_CatchUp() { var e = new ManualResetEvent(false); @@ -696,7 +699,7 @@ public void RepeatingTimer_Start_CatchUp() e.WaitOne(); } - [Fact] + [TestMethod] public void RepeatingTimer_Start_CatchUp_Throws() { var end = new ManualResetEvent(false); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimestampTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimestampTest.cs index e9b3475eea..d4f60c01f7 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimestampTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/TimestampTest.cs @@ -7,14 +7,17 @@ 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 TimestampTest : ReactiveTest { - [Fact] + [TestMethod] public void Timestamp_ArgumentChecking() { var scheduler = new TestScheduler(); @@ -25,7 +28,7 @@ public void Timestamp_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Timestamp(someObservable, null)); } - [Fact] + [TestMethod] public void Timestamp_Regular() { var scheduler = new TestScheduler(); @@ -58,7 +61,7 @@ public void Timestamp_Regular() ); } - [Fact] + [TestMethod] public void Timestamp_Empty() { var scheduler = new TestScheduler(); @@ -81,7 +84,7 @@ public void Timestamp_Empty() ); } - [Fact] + [TestMethod] public void Timestamp_Error() { var scheduler = new TestScheduler(); @@ -106,7 +109,7 @@ public void Timestamp_Error() ); } - [Fact] + [TestMethod] public void Timestamp_Never() { var scheduler = new TestScheduler(); @@ -127,7 +130,7 @@ public void Timestamp_Never() ); } - [Fact] + [TestMethod] public void Timestamp_DefaultScheduler() { Assert.True(Observable.Return(1).Timestamp().Count().First() == 1); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToArrayTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToArrayTest.cs index cc91b455a2..74f93cd73c 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToArrayTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToArrayTest.cs @@ -6,20 +6,21 @@ using System.Linq; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class ToArrayTest : ReactiveTest { - [Fact] + [TestMethod] public void ToArray_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToArray(null)); } - [Fact] + [TestMethod] public void ToArray_Completed() { var scheduler = new TestScheduler(); @@ -47,7 +48,7 @@ public void ToArray_Completed() ); } - [Fact] + [TestMethod] public void ToArray_Error() { var scheduler = new TestScheduler(); @@ -76,7 +77,7 @@ public void ToArray_Error() ); } - [Fact] + [TestMethod] public void ToArray_Disposed() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToAsyncTest.cs index 631a4bdaef..c3ac55234e 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToAsyncTest.cs @@ -8,14 +8,17 @@ 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 ToAsyncTest : ReactiveTest { - [Fact] + [TestMethod] public void ToAsync_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToAsync(default)); @@ -125,245 +128,245 @@ public void ToAsync_ArgumentChecking() ReactiveAssert.Throws(() => Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) => 1, null)); } - [Fact] + [TestMethod] public void ToAsync0() { Assert.True(Observable.ToAsync(() => 0)().ToEnumerable().SequenceEqual(new[] { 0 })); Assert.True(Observable.ToAsync(() => 0, Scheduler.Default)().ToEnumerable().SequenceEqual(new[] { 0 })); } - [Fact] + [TestMethod] public void ToAsync1() { Assert.True(Observable.ToAsync(a => a)(1).ToEnumerable().SequenceEqual(new[] { 1 })); Assert.True(Observable.ToAsync(a => a, Scheduler.Default)(1).ToEnumerable().SequenceEqual(new[] { 1 })); } - [Fact] + [TestMethod] public void ToAsync2() { Assert.True(Observable.ToAsync((a, b) => a + b)(1, 2).ToEnumerable().SequenceEqual(new[] { 1 + 2 })); Assert.True(Observable.ToAsync((a, b) => a + b, Scheduler.Default)(1, 2).ToEnumerable().SequenceEqual(new[] { 1 + 2 })); } - [Fact] + [TestMethod] public void ToAsync3() { Assert.True(Observable.ToAsync((a, b, c) => a + b + c)(1, 2, 3).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 })); Assert.True(Observable.ToAsync((a, b, c) => a + b + c, Scheduler.Default)(1, 2, 3).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 })); } - [Fact] + [TestMethod] public void ToAsync4() { Assert.True(Observable.ToAsync((a, b, c, d) => a + b + c + d)(1, 2, 3, 4).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 })); Assert.True(Observable.ToAsync((a, b, c, d) => a + b + c + d, Scheduler.Default)(1, 2, 3, 4).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 })); } - [Fact] + [TestMethod] public void ToAsync5() { Assert.True(Observable.ToAsync((a, b, c, d, e) => a + b + c + d + e)(1, 2, 3, 4, 5).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 })); Assert.True(Observable.ToAsync((a, b, c, d, e) => a + b + c + d + e, Scheduler.Default)(1, 2, 3, 4, 5).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 })); } - [Fact] + [TestMethod] public void ToAsync6() { Assert.True(Observable.ToAsync((a, b, c, d, e, f) => a + b + c + d + e + f)(1, 2, 3, 4, 5, 6).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f) => a + b + c + d + e + f, Scheduler.Default)(1, 2, 3, 4, 5, 6).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 })); } - [Fact] + [TestMethod] public void ToAsync7() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g) => a + b + c + d + e + f + g)(1, 2, 3, 4, 5, 6, 7).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g) => a + b + c + d + e + f + g, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 })); } - [Fact] + [TestMethod] public void ToAsync8() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h) => a + b + c + d + e + f + g + h)(1, 2, 3, 4, 5, 6, 7, 8).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h) => a + b + c + d + e + f + g + h, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 })); } - [Fact] + [TestMethod] public void ToAsync9() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i) => a + b + c + d + e + f + g + h + i)(1, 2, 3, 4, 5, 6, 7, 8, 9).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i) => a + b + c + d + e + f + g + h + i, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 })); } - [Fact] + [TestMethod] public void ToAsync10() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j) => a + b + c + d + e + f + g + h + i + j)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j) => a + b + c + d + e + f + g + h + i + j, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 })); } - [Fact] + [TestMethod] public void ToAsync11() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k) => a + b + c + d + e + f + g + h + i + j + k)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k) => a + b + c + d + e + f + g + h + i + j + k, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 })); } - [Fact] + [TestMethod] public void ToAsync12() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l) => a + b + c + d + e + f + g + h + i + j + k + l)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l) => a + b + c + d + e + f + g + h + i + j + k + l, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 })); } - [Fact] + [TestMethod] public void ToAsync13() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m) => a + b + c + d + e + f + g + h + i + j + k + l + m)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m) => a + b + c + d + e + f + g + h + i + j + k + l + m, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 })); } - [Fact] + [TestMethod] public void ToAsync14() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n) => a + b + c + d + e + f + g + h + i + j + k + l + m + n)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n) => a + b + c + d + e + f + g + h + i + j + k + l + m + n, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 })); } - [Fact] + [TestMethod] public void ToAsync15() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) => a + b + c + d + e + f + g + h + i + j + k + l + m + n + o)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) => a + b + c + d + e + f + g + h + i + j + k + l + m + n + o, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 })); } - [Fact] + [TestMethod] public void ToAsync16() { Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) => a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 })); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) => a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p, Scheduler.Default)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16).ToEnumerable().SequenceEqual(new[] { 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 })); } - [Fact] + [TestMethod] public void ToAsync_Error0() { var ex = new Exception(); Assert.True(Observable.ToAsync(() => { throw ex; })().Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error1() { var ex = new Exception(); Assert.True(Observable.ToAsync(a => { throw ex; })(1).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error2() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b) => { throw ex; })(1, 2).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error3() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c) => { throw ex; })(1, 2, 3).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error4() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d) => { throw ex; })(1, 2, 3, 4).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error5() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e) => { throw ex; })(1, 2, 3, 4, 5).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error6() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f) => { throw ex; })(1, 2, 3, 4, 5, 6).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error7() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g) => { throw ex; })(1, 2, 3, 4, 5, 6, 7).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error8() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error9() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error10() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error11() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error12() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error13() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error14() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error15() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsync_Error16() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) => { throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16).Materialize().ToEnumerable().SequenceEqual(new Notification[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction0() { var hasRun = false; @@ -372,14 +375,14 @@ public void ToAsyncAction0() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError0() { var ex = new Exception(); Assert.True(Observable.ToAsync(() => { throw ex; })().Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction1() { var hasRun = false; @@ -388,14 +391,14 @@ public void ToAsyncAction1() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError1() { var ex = new Exception(); Assert.True(Observable.ToAsync(a => { Assert.Equal(1, a); throw ex; })(1).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction2() { var hasRun = false; @@ -404,14 +407,14 @@ public void ToAsyncAction2() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError2() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b) => { Assert.Equal(1, a); Assert.Equal(2, b); throw ex; })(1, 2).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction3() { var hasRun = false; @@ -420,14 +423,14 @@ public void ToAsyncAction3() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError3() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); throw ex; })(1, 2, 3).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction4() { var hasRun = false; @@ -436,14 +439,14 @@ public void ToAsyncAction4() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError4() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); throw ex; })(1, 2, 3, 4).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction5() { var hasRun = false; @@ -452,14 +455,14 @@ public void ToAsyncAction5() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError5() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); throw ex; })(1, 2, 3, 4, 5).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction6() { var hasRun = false; @@ -468,14 +471,14 @@ public void ToAsyncAction6() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError6() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); throw ex; })(1, 2, 3, 4, 5, 6).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction7() { var hasRun = false; @@ -484,14 +487,14 @@ public void ToAsyncAction7() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError7() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); throw ex; })(1, 2, 3, 4, 5, 6, 7).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction8() { var hasRun = false; @@ -500,14 +503,14 @@ public void ToAsyncAction8() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError8() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction9() { var hasRun = false; @@ -516,14 +519,14 @@ public void ToAsyncAction9() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError9() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction10() { var hasRun = false; @@ -532,14 +535,14 @@ public void ToAsyncAction10() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError10() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); Assert.Equal(10, j); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction11() { var hasRun = false; @@ -548,14 +551,14 @@ public void ToAsyncAction11() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError11() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); Assert.Equal(10, j); Assert.Equal(11, k); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction12() { var hasRun = false; @@ -564,14 +567,14 @@ public void ToAsyncAction12() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError12() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); Assert.Equal(10, j); Assert.Equal(11, k); Assert.Equal(12, l); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction13() { var hasRun = false; @@ -580,14 +583,14 @@ public void ToAsyncAction13() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError13() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); Assert.Equal(10, j); Assert.Equal(11, k); Assert.Equal(12, l); Assert.Equal(13, m); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction14() { var hasRun = false; @@ -596,14 +599,14 @@ public void ToAsyncAction14() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError14() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); Assert.Equal(10, j); Assert.Equal(11, k); Assert.Equal(12, l); Assert.Equal(13, m); Assert.Equal(14, n); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction15() { var hasRun = false; @@ -612,14 +615,14 @@ public void ToAsyncAction15() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError15() { var ex = new Exception(); Assert.True(Observable.ToAsync((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) => { Assert.Equal(1, a); Assert.Equal(2, b); Assert.Equal(3, c); Assert.Equal(4, d); Assert.Equal(5, e); Assert.Equal(6, f); Assert.Equal(7, g); Assert.Equal(8, h); Assert.Equal(9, i); Assert.Equal(10, j); Assert.Equal(11, k); Assert.Equal(12, l); Assert.Equal(13, m); Assert.Equal(14, n); Assert.Equal(15, o); throw ex; })(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).Materialize().ToEnumerable().SequenceEqual(new[] { Notification.CreateOnError(ex) })); } - [Fact] + [TestMethod] public void ToAsyncAction16() { var hasRun = false; @@ -628,7 +631,7 @@ public void ToAsyncAction16() Assert.True(hasRun, "has run"); } - [Fact] + [TestMethod] public void ToAsyncActionError16() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToDictionaryTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToDictionaryTest.cs index 36a78b5f0b..620a7580da 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToDictionaryTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToDictionaryTest.cs @@ -8,14 +8,17 @@ 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 ToDictionaryTest : ReactiveTest { - [Fact] + [TestMethod] public void ToDictionary_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToDictionary(null, DummyFunc.Instance, EqualityComparer.Default)); @@ -32,7 +35,7 @@ public void ToDictionary_ArgumentChecking() ReactiveAssert.Throws(() => Observable.ToDictionary(DummyObservable.Instance, DummyFunc.Instance, null)); } - [Fact] + [TestMethod] public void ToDictionary_Completed() { var scheduler = new TestScheduler(); @@ -67,7 +70,7 @@ public void ToDictionary_Completed() ); } - [Fact] + [TestMethod] public void ToDictionary_Error() { var scheduler = new TestScheduler(); @@ -96,7 +99,7 @@ public void ToDictionary_Error() ); } - [Fact] + [TestMethod] public void ToDictionary_KeySelectorThrows() { var scheduler = new TestScheduler(); @@ -125,7 +128,7 @@ public void ToDictionary_KeySelectorThrows() ); } - [Fact] + [TestMethod] public void ToDictionary_ElementSelectorThrows() { var scheduler = new TestScheduler(); @@ -154,7 +157,7 @@ public void ToDictionary_ElementSelectorThrows() ); } - [Fact] + [TestMethod] public void ToDictionary_Disposed() { var scheduler = new TestScheduler(); @@ -179,7 +182,7 @@ public void ToDictionary_Disposed() ); } - [Fact] + [TestMethod] public void ToDictionary_MultipleAdd() { var scheduler = new TestScheduler(); @@ -206,7 +209,7 @@ public void ToDictionary_MultipleAdd() ); } - [Fact] + [TestMethod] public void ToDictionary_Default() { var d1 = Observable.Range(1, 10).ToDictionary(x => x.ToString()).First(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEnumerableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEnumerableTest.cs index 2256a838f7..bf319e4fb3 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEnumerableTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEnumerableTest.cs @@ -7,32 +7,35 @@ 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 ToEnumerableTest : ReactiveTest { - [Fact] + [TestMethod] public void ToEnumerable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToEnumerable(default(IObservable))); } - [Fact] + [TestMethod] public void ToEnumerable_Generic() { Assert.True(Observable.Range(0, 10).ToEnumerable().SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void ToEnumerable_NonGeneric() { Assert.True(((IEnumerable)Observable.Range(0, 10).ToEnumerable()).Cast().SequenceEqual(Enumerable.Range(0, 10))); } - [Fact] + [TestMethod] public void ToEnumerable_ManualGeneric() { var res = Observable.Range(0, 10).ToEnumerable(); @@ -45,7 +48,7 @@ public void ToEnumerable_ManualGeneric() Assert.False(ieg.MoveNext()); } - [Fact] + [TestMethod] public void ToEnumerable_ManualNonGeneric() { var res = (IEnumerable)Observable.Range(0, 10).ToEnumerable(); @@ -58,7 +61,7 @@ public void ToEnumerable_ManualNonGeneric() Assert.False(ien.MoveNext()); } - [Fact] + [TestMethod] public void ToEnumerable_ResetNotSupported() { ReactiveAssert.Throws(() => Observable.Range(0, 10).ToEnumerable().GetEnumerator().Reset()); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventPatternTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventPatternTest.cs index 43d490d9c0..f7f5dfd4d6 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventPatternTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventPatternTest.cs @@ -10,20 +10,23 @@ using System.Reactive.Subjects; using System.Reflection; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { + [TestClass] public class ToEventPatternTest : ReactiveTest { - [Fact] + [TestMethod] public void ToEventPattern_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToEventPattern(null)); } - [Fact] + [TestMethod] public void ToEventPattern_IEvent() { var src = new Subject>>(); @@ -50,7 +53,7 @@ public void ToEventPattern_IEvent() Assert.True(lst.SequenceEqual(new[] { 42, 43 })); } - [Fact] + [TestMethod] public void ToEventPattern_IEvent_Fails() { var src = new Subject>>(); @@ -77,7 +80,7 @@ public void ToEventPattern_IEvent_Fails() Assert.True(lst.SequenceEqual(new[] { 42, 43 })); } - [Fact] + [TestMethod] public void ToEventPattern_IEvent_Completes() { var src = new Subject>>(); @@ -122,7 +125,7 @@ public EventArgs(T value) } } - [Fact] + [TestMethod] public void FromEventPattern_ToEventPattern() { var src = new EventSrc(); @@ -151,7 +154,7 @@ public void FromEventPattern_ToEventPattern() Assert.True(lst.SequenceEqual(new[] { "foo", "baz" })); } - [Fact] + [TestMethod] public void ToEvent_DuplicateHandlers() { var src = new Subject(); @@ -183,7 +186,7 @@ public void ToEvent_DuplicateHandlers() Assert.Equal(4, num); } - [Fact] + [TestMethod] public void ToEvent_SourceCompletes() { var src = new Subject(); @@ -209,7 +212,7 @@ public void ToEvent_SourceCompletes() Assert.True(tbl.Count == 0); } - [Fact] + [TestMethod] public void ToEvent_SourceFails() { var src = new Subject(); @@ -236,7 +239,7 @@ public void ToEvent_SourceFails() Assert.True(tbl.Count == 0); } - [Fact] + [TestMethod] public void ToEvent_DoneImmediately() { var src = Observable.Empty(); @@ -256,7 +259,7 @@ public void ToEvent_DoneImmediately() } } - [Fact] + [TestMethod] public void ToEvent_UnbalancedHandlers() { var src = new Subject(); @@ -295,7 +298,7 @@ private static Dictionary> GetSubscriptionTable(obj return (Dictionary>)evt.GetType().GetField("_subscriptions", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(evt); } - [Fact] + [TestMethod] public void EventPattern_Equality() { var e1 = new EventPattern("Bart", EventArgs.Empty); @@ -313,7 +316,7 @@ public void EventPattern_Equality() Assert.False(e1 == null); } - [Fact] + [TestMethod] public void EventPattern_Inequality() { var a1 = new MyEventArgs(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventTest.cs index e55138eb1f..64ff3a3817 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToEventTest.cs @@ -9,14 +9,17 @@ 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 ToEventTest : ReactiveTest { - [Fact] + [TestMethod] public void ToEvent_ArgumentChecks() { ReactiveAssert.Throws(() => Observable.ToEvent(default)); @@ -24,7 +27,7 @@ public void ToEvent_ArgumentChecks() ReactiveAssert.Throws(() => Observable.ToEvent(default(IObservable>))); } - [Fact] + [TestMethod] public void ToEvent_Unit() { var src = new Subject(); @@ -52,7 +55,7 @@ public void ToEvent_Unit() Assert.Equal(2, num); } - [Fact] + [TestMethod] public void ToEvent_NonUnit() { var src = new Subject(); @@ -76,7 +79,7 @@ public void ToEvent_NonUnit() Assert.True(lst.SequenceEqual(new[] { 1, 2 })); } - [Fact] + [TestMethod] public void ToEvent_FromEvent() { var src = new Subject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListObservableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListObservableTest.cs index fb7a8f5a10..f23b9e450a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListObservableTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListObservableTest.cs @@ -7,21 +7,24 @@ 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 ToListObservableTest : ReactiveTest { - [Fact] + [TestMethod] public void ToListObservable_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).ToListObservable()); ReactiveAssert.Throws(() => Observable.Never().ToListObservable().Subscribe(null)); } - [Fact] + [TestMethod] public void ToListObservable_OnNext() { var scheduler = new TestScheduler(); @@ -41,7 +44,7 @@ public void ToListObservable_OnNext() ); } - [Fact] + [TestMethod] public void ToListObservable_OnError() { var scheduler = new TestScheduler(); @@ -72,7 +75,7 @@ public void ToListObservable_OnError() ); } - [Fact] + [TestMethod] public void ToListObservable_OnCompleted() { var scheduler = new TestScheduler(); @@ -99,7 +102,7 @@ public void ToListObservable_OnCompleted() Assert.Equal(3, s.Value); } - [Fact] + [TestMethod] public void ToListObservable_Disposed() { var scheduler = new TestScheduler(); @@ -122,7 +125,7 @@ public void ToListObservable_Disposed() ); } - [Fact] + [TestMethod] public void ToListObservable_Never() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListTest.cs index 9354313a52..b86a09c345 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToListTest.cs @@ -7,20 +7,21 @@ using System.Linq; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class ToListTest : ReactiveTest { - [Fact] + [TestMethod] public void ToList_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToList(null)); } - [Fact] + [TestMethod] public void ToList_Completed() { var scheduler = new TestScheduler(); @@ -48,7 +49,7 @@ public void ToList_Completed() ); } - [Fact] + [TestMethod] public void ToList_Error() { var scheduler = new TestScheduler(); @@ -77,7 +78,7 @@ public void ToList_Error() ); } - [Fact] + [TestMethod] public void ToList_Disposed() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToLookupTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToLookupTest.cs index 9d9391db5d..4f64850073 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToLookupTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToLookupTest.cs @@ -8,14 +8,17 @@ 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 ToLookupTest : ReactiveTest { - [Fact] + [TestMethod] public void ToLookup_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToLookup(null, DummyFunc.Instance, EqualityComparer.Default)); @@ -33,7 +36,7 @@ public void ToLookup_ArgumentChecking() } - [Fact] + [TestMethod] public void ToLookup_Completed() { var scheduler = new TestScheduler(); @@ -66,7 +69,7 @@ public void ToLookup_Completed() ); } - [Fact] + [TestMethod] public void ToLookup_Error() { var scheduler = new TestScheduler(); @@ -95,7 +98,7 @@ public void ToLookup_Error() ); } - [Fact] + [TestMethod] public void ToLookup_KeySelectorThrows() { var scheduler = new TestScheduler(); @@ -124,7 +127,7 @@ public void ToLookup_KeySelectorThrows() ); } - [Fact] + [TestMethod] public void ToLookup_ElementSelectorThrows() { var scheduler = new TestScheduler(); @@ -153,7 +156,7 @@ public void ToLookup_ElementSelectorThrows() ); } - [Fact] + [TestMethod] public void ToLookup_Disposed() { var scheduler = new TestScheduler(); @@ -178,7 +181,7 @@ public void ToLookup_Disposed() ); } - [Fact] + [TestMethod] public void ToLookup_Default() { var d1 = Observable.Range(1, 10).ToLookup(x => (x % 2).ToString()).First(); @@ -191,7 +194,7 @@ public void ToLookup_Default() d3["0"].AssertEqual(2, 4, 6, 8, 10); } - [Fact] + [TestMethod] public void ToLookup_Contains() { var d1 = Observable.Range(1, 10).ToLookup(x => (x % 2).ToString()).First(); @@ -199,7 +202,7 @@ public void ToLookup_Contains() Assert.False(d1.Contains("2")); } - [Fact] + [TestMethod] public void ToLookup_Hides_Internal_List() { var d1 = Observable.Range(1, 10).ToLookup(x => (x % 2).ToString()).First(); @@ -207,7 +210,7 @@ public void ToLookup_Hides_Internal_List() Assert.False(d1["0"] is IList); } - [Fact] + [TestMethod] public void ToLookup_Groups() { var d1 = Observable.Range(1, 10).ToLookup(x => (x % 2).ToString()).First(); @@ -229,7 +232,7 @@ public void ToLookup_Groups() } } - [Fact] + [TestMethod] public void ToLookup_Groups_2() { var d1 = Observable.Range(1, 10).ToLookup(x => (x % 2).ToString()).First(); @@ -263,7 +266,7 @@ public void ToLookup_Groups_2() } } - [Fact] + [TestMethod] public void ToLookup_IndexerForInvalidKey() { var d1 = Observable.Range(1, 10).ToLookup(x => (x % 2).ToString()).First(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToObservableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToObservableTest.cs index efe9567b4a..0dc290056f 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToObservableTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ToObservableTest.cs @@ -11,14 +11,17 @@ 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 ToObservableTest : ReactiveTest { - [Fact] + [TestMethod] public void EnumerableToObservable_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToObservable((IEnumerable)null, DummyScheduler.Instance)); @@ -27,7 +30,7 @@ public void EnumerableToObservable_ArgumentChecking() ReactiveAssert.Throws(() => Observable.ToObservable(NullEnumeratorEnumerable.Instance, Scheduler.CurrentThread).Subscribe()); } - [Fact] + [TestMethod] public void EnumerableToObservable_Complete() { var scheduler = new TestScheduler(); @@ -53,7 +56,7 @@ public void EnumerableToObservable_Complete() ); } - [Fact] + [TestMethod] public void EnumerableToObservable_Dispose() { var scheduler = new TestScheduler(); @@ -77,7 +80,7 @@ public void EnumerableToObservable_Dispose() ); } - [Fact] + [TestMethod] public void EnumerableToObservable_Error() { var scheduler = new TestScheduler(); @@ -103,14 +106,14 @@ public void EnumerableToObservable_Error() ); } - [Fact] + [TestMethod] public void EnumerableToObservable_Default_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.ToObservable((IEnumerable)null)); ReactiveAssert.Throws(() => Observable.ToObservable(DummyEnumerable.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void EnumerableToObservable_Default() { var xs = new[] { 4, 3, 1, 5, 9, 2 }; @@ -119,7 +122,7 @@ public void EnumerableToObservable_Default() } #if !NO_PERF - [Fact] + [TestMethod] public void EnumerableToObservable_LongRunning_Complete() { var start = default(ManualResetEvent); @@ -139,7 +142,7 @@ public void EnumerableToObservable_LongRunning_Complete() Assert.True(e.SequenceEqual(lst)); } - [Fact] + [TestMethod] [MethodImpl(MethodImplOptions.NoOptimization)] public void EnumerableToObservable_LongRunning_Dispose() { @@ -167,7 +170,7 @@ public void EnumerableToObservable_LongRunning_Dispose() Assert.True(e.Take(100).SequenceEqual(lst.Take(100))); } - [Fact] + [TestMethod] public void EnumerableToObservable_LongRunning_Error() { var start = default(ManualResetEvent); @@ -198,7 +201,7 @@ private static IEnumerable EnumerableToObservable_Error_Core(Exception ex) throw ex; } - [Fact] + [TestMethod] public void EnumerableToObservable_GetEnumeratorThrows() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingAsyncTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingAsyncTest.cs index 69ba738939..ce30eaf7f7 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingAsyncTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingAsyncTest.cs @@ -10,21 +10,24 @@ 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 UsingAsyncTest : ReactiveTest { - [Fact] + [TestMethod] public void UsingAsync_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Using(null, (res, ct) => null)); ReactiveAssert.Throws(() => Observable.Using(ct => null, null)); } - [Fact] + [TestMethod] public void UsingAsync_Simple() { var done = new CountdownEvent(1); @@ -40,7 +43,7 @@ public void UsingAsync_Simple() Assert.True(done.Wait(5000), "done.Wait(5000)"); } - [Fact] + [TestMethod] public void UsingAsync_CancelResource() { var N = 10;// 0000; @@ -86,7 +89,7 @@ public void UsingAsync_CancelResource() } } - [Fact] + [TestMethod] public void UsingAsync_CancelFactory() { var N = 10;// 0000; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingTest.cs index 1bb5689d8f..bbc7bcaf56 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/UsingTest.cs @@ -8,14 +8,17 @@ 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 UsingTest : ReactiveTest { - [Fact] + [TestMethod] public void Using_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Using(null, DummyFunc>.Instance)); @@ -24,7 +27,7 @@ public void Using_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Using(() => DummyDisposable.Instance, d => DummyObservable.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void Using_Null() { var scheduler = new TestScheduler(); @@ -72,7 +75,7 @@ public void Using_Null() Assert.Null(disposable); } - [Fact] + [TestMethod] public void Using_Complete() { var scheduler = new TestScheduler(); @@ -123,7 +126,7 @@ public void Using_Complete() ); } - [Fact] + [TestMethod] public void Using_Error() { var scheduler = new TestScheduler(); @@ -175,7 +178,7 @@ public void Using_Error() ); } - [Fact] + [TestMethod] public void Using_Dispose() { var scheduler = new TestScheduler(); @@ -225,7 +228,7 @@ public void Using_Dispose() ); } - [Fact] + [TestMethod] public void Using_ThrowResourceSelector() { var scheduler = new TestScheduler(); @@ -257,7 +260,7 @@ public void Using_ThrowResourceSelector() Assert.Equal(1, disposeInvoked); } - [Fact] + [TestMethod] public void Using_ThrowResourceUsage() { var scheduler = new TestScheduler(); @@ -297,7 +300,7 @@ public void Using_ThrowResourceUsage() ); } - [Fact] + [TestMethod] public void Using_NestedCompleted() { var order = ""; @@ -312,7 +315,7 @@ public void Using_NestedCompleted() Assert.Equal("1234", order); } - [Fact] + [TestMethod] public void Using_NestedDisposed() { var order = ""; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WaitTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WaitTest.cs index a2f2d3f181..9098983222 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WaitTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WaitTest.cs @@ -6,21 +6,24 @@ 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 WaitTest : ReactiveTest { - [Fact] + [TestMethod] public void Wait_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Wait(default(IObservable))); } #if !NO_THREAD - [Fact] + [TestMethod] public void Wait_Return() { var x = 42; @@ -30,13 +33,13 @@ public void Wait_Return() } #endif - [Fact] + [TestMethod] public void Wait_Empty() { ReactiveAssert.Throws(() => Observable.Empty().Wait()); } - [Fact] + [TestMethod] public void Wait_Throw() { var ex = new Exception(); @@ -47,7 +50,7 @@ public void Wait_Throw() } #if !NO_THREAD - [Fact] + [TestMethod] public void Wait_Range() { var n = 42; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhenTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhenTest.cs index ac2503d0c7..c53af928ae 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhenTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhenTest.cs @@ -8,21 +8,24 @@ using System.Reactive.Joins; 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 WhenTest : ReactiveTest { - [Fact] + [TestMethod] public void When_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.When(null)); ReactiveAssert.Throws(() => Observable.When((IEnumerable>)null)); } - [Fact] + [TestMethod] public void WhenMultipleDataSymmetric() { var scheduler = new TestScheduler(); @@ -55,7 +58,7 @@ public void WhenMultipleDataSymmetric() ); } - [Fact] + [TestMethod] public void WhenMultipleDataAsymmetric() { var scheduler = new TestScheduler(); @@ -86,7 +89,7 @@ public void WhenMultipleDataAsymmetric() ); } - [Fact] + [TestMethod] public void WhenEmptyEmpty() { var scheduler = new TestScheduler(); @@ -110,7 +113,7 @@ public void WhenEmptyEmpty() ); } - [Fact] + [TestMethod] public void WhenNeverNever() { var scheduler = new TestScheduler(); @@ -128,7 +131,7 @@ public void WhenNeverNever() ); } - [Fact] + [TestMethod] public void WhenThrowNonEmpty() { var ex = new Exception(); @@ -153,7 +156,7 @@ public void WhenThrowNonEmpty() ); } - [Fact] + [TestMethod] public void ComplicatedWhen() { var scheduler = new TestScheduler(); @@ -196,7 +199,7 @@ public void ComplicatedWhen() ); } - [Fact] + [TestMethod] public void When_PlansIteratorThrows() { var ex = new Exception(); @@ -216,7 +219,7 @@ private IEnumerable> GetPlans(Exception ex) yield break; } - [Fact] + [TestMethod] public void SameSource() { var source = Observable.Range(1, 5); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhereTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhereTest.cs index 0417c61100..7ed5c28afa 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhereTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhereTest.cs @@ -9,14 +9,17 @@ 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 WhereTest : ReactiveTest { - [Fact] + [TestMethod] public void Where_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).Where(DummyFunc.Instance)); @@ -43,7 +46,7 @@ private static bool IsPrime(int i) return true; } - [Fact] + [TestMethod] public void Where_Complete() { var scheduler = new TestScheduler(); @@ -91,7 +94,7 @@ public void Where_Complete() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void Where_True() { var scheduler = new TestScheduler(); @@ -141,7 +144,7 @@ public void Where_True() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void Where_False() { var scheduler = new TestScheduler(); @@ -182,7 +185,7 @@ public void Where_False() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void Where_Dispose() { var scheduler = new TestScheduler(); @@ -226,7 +229,7 @@ public void Where_Dispose() Assert.Equal(5, invoked); } - [Fact] + [TestMethod] public void Where_Error() { var scheduler = new TestScheduler(); @@ -276,7 +279,7 @@ public void Where_Error() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void Where_Throw() { var scheduler = new TestScheduler(); @@ -328,7 +331,7 @@ public void Where_Throw() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void Where_DisposeInPredicate() { var scheduler = new TestScheduler(); @@ -388,7 +391,7 @@ public void Where_DisposeInPredicate() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void WhereWhereOptimization_Regular() { var scheduler = new TestScheduler(); @@ -421,7 +424,7 @@ public void WhereWhereOptimization_Regular() ); } - [Fact] + [TestMethod] public void WhereWhereOptimization_SecondPredicateThrows() { var scheduler = new TestScheduler(); @@ -462,7 +465,7 @@ public void WhereWhereOptimization_SecondPredicateThrows() ); } - [Fact] + [TestMethod] public void WhereIndex_ArgumentChecking() { ReactiveAssert.Throws(() => ((IObservable)null).Where(DummyFunc.Instance)); @@ -470,7 +473,7 @@ public void WhereIndex_ArgumentChecking() ReactiveAssert.Throws(() => DummyObservable.Instance.Where(DummyFunc.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void WhereIndex_Complete() { var scheduler = new TestScheduler(); @@ -516,7 +519,7 @@ public void WhereIndex_Complete() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void WhereIndex_True() { var scheduler = new TestScheduler(); @@ -566,7 +569,7 @@ public void WhereIndex_True() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void WhereIndex_False() { var scheduler = new TestScheduler(); @@ -607,7 +610,7 @@ public void WhereIndex_False() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void WhereIndex_Dispose() { var scheduler = new TestScheduler(); @@ -650,7 +653,7 @@ public void WhereIndex_Dispose() Assert.Equal(5, invoked); } - [Fact] + [TestMethod] public void WhereIndex_Error() { var scheduler = new TestScheduler(); @@ -697,7 +700,7 @@ public void WhereIndex_Error() Assert.Equal(9, invoked); } - [Fact] + [TestMethod] public void WhereIndex_Throw() { var scheduler = new TestScheduler(); @@ -748,7 +751,7 @@ public void WhereIndex_Throw() Assert.Equal(4, invoked); } - [Fact] + [TestMethod] public void WhereIndex_DisposeInPredicate() { var scheduler = new TestScheduler(); @@ -808,7 +811,7 @@ public void WhereIndex_DisposeInPredicate() Assert.Equal(6, invoked); } - [Fact] + [TestMethod] public void Where_Where1() { var scheduler = new TestScheduler(); @@ -839,7 +842,7 @@ public void Where_Where1() ); } - [Fact] + [TestMethod] public void Where_Where2() { var scheduler = new TestScheduler(); @@ -870,7 +873,7 @@ public void Where_Where2() ); } - [Fact] + [TestMethod] public void Where_Where3() { var scheduler = new TestScheduler(); @@ -901,7 +904,7 @@ public void Where_Where3() ); } - [Fact] + [TestMethod] public void Where_Where4() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhileTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhileTest.cs index 43a028efc7..f864541e92 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhileTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WhileTest.cs @@ -6,21 +6,22 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class WhileTest : ReactiveTest { - [Fact] + [TestMethod] public void While_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.While(default, DummyObservable.Instance)); ReactiveAssert.Throws(() => Observable.While(DummyFunc.Instance, default(IObservable))); } - [Fact] + [TestMethod] public void While_AlwaysFalse() { var scheduler = new TestScheduler(); @@ -43,7 +44,7 @@ public void While_AlwaysFalse() ); } - [Fact] + [TestMethod] public void While_AlwaysTrue() { var scheduler = new TestScheduler(); @@ -81,7 +82,7 @@ public void While_AlwaysTrue() ); } - [Fact] + [TestMethod] public void While_AlwaysTrue_Throw() { var scheduler = new TestScheduler(); @@ -103,7 +104,7 @@ public void While_AlwaysTrue_Throw() ); } - [Fact] + [TestMethod] public void While_AlwaysTrue_Infinite() { var scheduler = new TestScheduler(); @@ -123,7 +124,7 @@ public void While_AlwaysTrue_Infinite() ); } - [Fact] + [TestMethod] public void While_SometimesTrue() { var scheduler = new TestScheduler(); @@ -163,7 +164,7 @@ private static T Throw(Exception ex) throw ex; } - [Fact] + [TestMethod] public void While_SometimesThrows() { var scheduler = new TestScheduler(); @@ -202,7 +203,7 @@ public void While_SometimesThrows() #region General tests for loops #if HAS_STACKTRACE - [Fact] + [TestMethod] public void LoopTest1() { var loop = Observable.Defer(() => @@ -232,7 +233,7 @@ public void LoopTest1() Assert.True(std.Distinct().Count() == 1); } - [Fact] + [TestMethod] public void LoopTest2() { var n = 0; diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WindowTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WindowTest.cs index 351623d2ba..b051364cd4 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WindowTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WindowTest.cs @@ -9,15 +9,18 @@ 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 WindowTest : ReactiveTest { #region + Observable + - [Fact] + [TestMethod] public void Window_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Window(default(IObservable), DummyFunc>.Instance)); @@ -29,7 +32,7 @@ public void Window_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Window(DummyObservable.Instance, default(IObservable))); } - [Fact] + [TestMethod] public void Window_Closings_Basic() { var scheduler = new TestScheduler(); @@ -71,7 +74,7 @@ public void Window_Closings_Basic() ); } - [Fact] + [TestMethod] public void Window_Closings_InnerSubscriptions() { var scheduler = new TestScheduler(); @@ -148,7 +151,7 @@ public void Window_Closings_InnerSubscriptions() ); } - [Fact] + [TestMethod] public void Window_Closings_Empty() { var scheduler = new TestScheduler(); @@ -190,7 +193,7 @@ public void Window_Closings_Empty() ); } - [Fact] + [TestMethod] public void Window_Closings_Dispose() { var scheduler = new TestScheduler(); @@ -228,7 +231,7 @@ public void Window_Closings_Dispose() ); } - [Fact] + [TestMethod] public void Window_Closings_Error() { var scheduler = new TestScheduler(); @@ -272,7 +275,7 @@ public void Window_Closings_Error() ); } - [Fact] + [TestMethod] public void Window_Closings_Throw() { var scheduler = new TestScheduler(); @@ -306,7 +309,7 @@ public void Window_Closings_Throw() ); } - [Fact] + [TestMethod] public void Window_Closings_WindowClose_Error() { var scheduler = new TestScheduler(); @@ -340,7 +343,7 @@ public void Window_Closings_WindowClose_Error() ); } - [Fact] + [TestMethod] public void Window_Closings_Default() { var scheduler = new TestScheduler(); @@ -382,7 +385,7 @@ public void Window_Closings_Default() ); } - [Fact] + [TestMethod] public void Window_OpeningClosings_Basic() { var scheduler = new TestScheduler(); @@ -439,7 +442,7 @@ public void Window_OpeningClosings_Basic() ); } - [Fact] + [TestMethod] public void Window_OpeningClosings_Throw() { var scheduler = new TestScheduler(); @@ -485,7 +488,7 @@ public void Window_OpeningClosings_Throw() ); } - [Fact] + [TestMethod] public void Window_OpeningClosings_Dispose() { var scheduler = new TestScheduler(); @@ -533,7 +536,7 @@ public void Window_OpeningClosings_Dispose() ); } - [Fact] + [TestMethod] public void Window_OpeningClosings_Data_Error() { var scheduler = new TestScheduler(); @@ -580,7 +583,7 @@ public void Window_OpeningClosings_Data_Error() ); } - [Fact] + [TestMethod] public void Window_OpeningClosings_Window_Error() { var scheduler = new TestScheduler(); @@ -630,7 +633,7 @@ public void Window_OpeningClosings_Window_Error() ); } - [Fact] + [TestMethod] public void Window_Boundaries_Simple() { var scheduler = new TestScheduler(); @@ -683,7 +686,7 @@ public void Window_Boundaries_Simple() ); } - [Fact] + [TestMethod] public void Window_Boundaries_OnCompletedBoundaries() { var scheduler = new TestScheduler(); @@ -730,7 +733,7 @@ public void Window_Boundaries_OnCompletedBoundaries() ); } - [Fact] + [TestMethod] public void Window_Boundaries_OnErrorSource() { var ex = new Exception(); @@ -777,7 +780,7 @@ public void Window_Boundaries_OnErrorSource() ); } - [Fact] + [TestMethod] public void Window_Boundaries_OnErrorBoundaries() { var ex = new Exception(); @@ -826,7 +829,7 @@ public void Window_Boundaries_OnErrorBoundaries() ); } - [Fact] + [TestMethod] public void WindowWithCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Window(default(IObservable), 1, 1)); @@ -836,7 +839,7 @@ public void WindowWithCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Window(DummyObservable.Instance, 0)); } - [Fact] + [TestMethod] public void WindowWithCount_Basic() { var scheduler = new TestScheduler(); @@ -878,7 +881,7 @@ public void WindowWithCount_Basic() ); } - [Fact] + [TestMethod] public void WindowWithCount_InnerTimings() { var scheduler = new TestScheduler(); @@ -957,7 +960,7 @@ public void WindowWithCount_InnerTimings() ); } - [Fact] + [TestMethod] public void WindowWithCount_InnerTimings_DisposeOuter() { var scheduler = new TestScheduler(); @@ -1042,7 +1045,7 @@ public void WindowWithCount_InnerTimings_DisposeOuter() ); } - [Fact] + [TestMethod] public void WindowWithCount_InnerTimings_DisposeOuterAndInners() { var scheduler = new TestScheduler(); @@ -1126,7 +1129,7 @@ public void WindowWithCount_InnerTimings_DisposeOuterAndInners() ); } - [Fact] + [TestMethod] public void WindowWithCount_Disposed() { var scheduler = new TestScheduler(); @@ -1163,7 +1166,7 @@ public void WindowWithCount_Disposed() ); } - [Fact] + [TestMethod] public void WindowWithCount_Error() { var scheduler = new TestScheduler(); @@ -1207,7 +1210,7 @@ public void WindowWithCount_Error() ); } - [Fact] + [TestMethod] public void WindowWithCount_Default() { Observable.Range(1, 10).Window(3).Skip(1).First().SequenceEqual(new[] { 4, 5, 6 }.ToObservable()); @@ -1219,7 +1222,7 @@ public void WindowWithCount_Default() #region + Timed + - [Fact] + [TestMethod] public void Window_Time_Basic() { var scheduler = new TestScheduler(); @@ -1263,7 +1266,7 @@ public void Window_Time_Basic() ); } - [Fact] + [TestMethod] public void Window_Time_Basic_Periodic() { var scheduler = new PeriodicTestScheduler(); @@ -1313,7 +1316,7 @@ public void Window_Time_Basic_Periodic() #endif } - [Fact] + [TestMethod] public void Window_Time_Basic_Periodic_Error() { var ex = new Exception(); @@ -1360,7 +1363,7 @@ public void Window_Time_Basic_Periodic_Error() #endif } - [Fact] + [TestMethod] public void Window_Time_Basic_Both() { var scheduler = new TestScheduler(); @@ -1414,7 +1417,7 @@ public void Window_Time_Basic_Both() ); } - [Fact] + [TestMethod] public void WindowWithTime_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Window(default(IObservable), TimeSpan.FromTicks(1), TimeSpan.FromTicks(1), DummyScheduler.Instance)); @@ -1431,7 +1434,7 @@ public void WindowWithTime_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Window(DummyObservable.Instance, TimeSpan.FromTicks(-1))); } - [Fact] + [TestMethod] public void WindowWithTime_Basic1() { var scheduler = new TestScheduler(); @@ -1473,7 +1476,7 @@ public void WindowWithTime_Basic1() ); } - [Fact] + [TestMethod] public void WindowWithTime_Basic2() { var scheduler = new TestScheduler(); @@ -1510,7 +1513,7 @@ public void WindowWithTime_Basic2() ); } - [Fact] + [TestMethod] public void WindowWithTime_Error() { var scheduler = new TestScheduler(); @@ -1554,7 +1557,7 @@ public void WindowWithTime_Error() ); } - [Fact] + [TestMethod] public void WindowWithTime_Disposed() { var scheduler = new TestScheduler(); @@ -1592,7 +1595,7 @@ public void WindowWithTime_Disposed() ); } - [Fact] + [TestMethod] public void WindowWithTime_Basic_Same() { var scheduler = new TestScheduler(); @@ -1631,14 +1634,14 @@ public void WindowWithTime_Basic_Same() ); } - [Fact] + [TestMethod] public void WindowWithTime_Default() { Observable.Range(0, 10).Window(TimeSpan.FromDays(1), TimeSpan.FromDays(1)).SelectMany(Observable.ToList).First().AssertEqual(Enumerable.Range(0, 10)); Observable.Range(0, 10).Window(TimeSpan.FromDays(1)).SelectMany(Observable.ToList).First().AssertEqual(Enumerable.Range(0, 10)); } - [Fact] + [TestMethod] public void WindowWithTimeOrCount_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Window(default(IObservable), TimeSpan.FromTicks(1), 1, DummyScheduler.Instance)); @@ -1650,7 +1653,7 @@ public void WindowWithTimeOrCount_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Window(DummyObservable.Instance, TimeSpan.FromTicks(1), 0)); } - [Fact] + [TestMethod] public void WindowWithTimeOrCount_Basic() { var scheduler = new TestScheduler(); @@ -1690,7 +1693,7 @@ public void WindowWithTimeOrCount_Basic() ); } - [Fact] + [TestMethod] public void WindowWithTimeOrCount_Error() { var scheduler = new TestScheduler(); @@ -1732,7 +1735,7 @@ public void WindowWithTimeOrCount_Error() ); } - [Fact] + [TestMethod] public void WindowWithTimeOrCount_Disposed() { var scheduler = new TestScheduler(); @@ -1770,7 +1773,7 @@ public void WindowWithTimeOrCount_Disposed() ); } - [Fact] + [TestMethod] public void WindowWithTimeOrCount_Default() { Observable.Range(1, 10).Window(TimeSpan.FromDays(1), 3).Skip(1).First().SequenceEqual(Observable.Range(4, 3)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WithLatestFromTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WithLatestFromTest.cs index cc7a6436f8..18a1af0dcc 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WithLatestFromTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/WithLatestFromTest.cs @@ -6,14 +6,15 @@ using System.Reactive.Linq; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { + [TestClass] public class WithLatestFromTest : ReactiveTest { - [Fact] + [TestMethod] public void WithLatestFrom_ArgumentChecking() { var someObservable = DummyObservable.Instance; @@ -23,7 +24,7 @@ public void WithLatestFrom_ArgumentChecking() ReactiveAssert.Throws(() => Observable.WithLatestFrom(someObservable, default, (_, __) => 0)); } - [Fact] + [TestMethod] public void WithLatestFrom_Simple1() { var scheduler = new TestScheduler(); @@ -73,7 +74,7 @@ public void WithLatestFrom_Simple1() ); } - [Fact] + [TestMethod] public void WithLatestFrom_Simple2() { var scheduler = new TestScheduler(); @@ -116,7 +117,7 @@ public void WithLatestFrom_Simple2() ); } - [Fact] + [TestMethod] public void WithLatestFrom_Simple3() { var scheduler = new TestScheduler(); @@ -160,7 +161,7 @@ public void WithLatestFrom_Simple3() ); } - [Fact] + [TestMethod] public void WithLatestFrom_Error1() { var scheduler = new TestScheduler(); @@ -212,7 +213,7 @@ public void WithLatestFrom_Error1() ); } - [Fact] + [TestMethod] public void WithLatestFrom_Error2() { var scheduler = new TestScheduler(); @@ -256,7 +257,7 @@ public void WithLatestFrom_Error2() ); } - [Fact] + [TestMethod] public void WithLatestFrom_Error3() { var scheduler = new TestScheduler(); @@ -306,7 +307,7 @@ public void WithLatestFrom_Error3() ); } - [Fact] + [TestMethod] public void WithLatestFrom_immediate() { var scheduler = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ZipTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ZipTest.cs index 79ab0c3cd2..25134b3f6b 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ZipTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Observable/ZipTest.cs @@ -13,17 +13,20 @@ using System.Threading; using Microsoft.Reactive.Testing; using ReactiveTests.Dummies; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { #pragma warning disable IDE0039 // Use local function + [TestClass] public class ZipTest : ReactiveTest { #region ArgumentChecking - [Fact] + [TestMethod] public void Zip_ArgumentChecking() { var someObservable = DummyObservable.Instance; @@ -37,7 +40,7 @@ public void Zip_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Zip(someObservable, default(IEnumerable), (_, __) => 0)); } - [Fact] + [TestMethod] public void Zip_ArgumentCheckingHighArity() { var xs = DummyObservable.Instance; @@ -198,7 +201,7 @@ public void Zip_ArgumentCheckingHighArity() #region Never/Never - [Fact] + [TestMethod] public void Zip_Never2() { var scheduler = new TestScheduler(); @@ -219,7 +222,7 @@ public void Zip_Never2() } } - [Fact] + [TestMethod] public void Zip_Never3() { var scheduler = new TestScheduler(); @@ -241,7 +244,7 @@ public void Zip_Never3() } } - [Fact] + [TestMethod] public void Zip_Never4() { var scheduler = new TestScheduler(); @@ -264,7 +267,7 @@ public void Zip_Never4() } } - [Fact] + [TestMethod] public void Zip_Never5() { var scheduler = new TestScheduler(); @@ -288,7 +291,7 @@ public void Zip_Never5() } } - [Fact] + [TestMethod] public void Zip_Never6() { var scheduler = new TestScheduler(); @@ -313,7 +316,7 @@ public void Zip_Never6() } } - [Fact] + [TestMethod] public void Zip_Never7() { var scheduler = new TestScheduler(); @@ -339,7 +342,7 @@ public void Zip_Never7() } } - [Fact] + [TestMethod] public void Zip_Never8() { var scheduler = new TestScheduler(); @@ -366,7 +369,7 @@ public void Zip_Never8() } } - [Fact] + [TestMethod] public void Zip_Never9() { var scheduler = new TestScheduler(); @@ -394,7 +397,7 @@ public void Zip_Never9() } } - [Fact] + [TestMethod] public void Zip_Never10() { var scheduler = new TestScheduler(); @@ -423,7 +426,7 @@ public void Zip_Never10() } } - [Fact] + [TestMethod] public void Zip_Never11() { var scheduler = new TestScheduler(); @@ -453,7 +456,7 @@ public void Zip_Never11() } } - [Fact] + [TestMethod] public void Zip_Never12() { var scheduler = new TestScheduler(); @@ -484,7 +487,7 @@ public void Zip_Never12() } } - [Fact] + [TestMethod] public void Zip_Never13() { var scheduler = new TestScheduler(); @@ -516,7 +519,7 @@ public void Zip_Never13() } } - [Fact] + [TestMethod] public void Zip_Never14() { var scheduler = new TestScheduler(); @@ -549,7 +552,7 @@ public void Zip_Never14() } } - [Fact] + [TestMethod] public void Zip_Never15() { var scheduler = new TestScheduler(); @@ -583,7 +586,7 @@ public void Zip_Never15() } } - [Fact] + [TestMethod] public void Zip_Never16() { var scheduler = new TestScheduler(); @@ -622,7 +625,7 @@ public void Zip_Never16() #region Never/Empty - [Fact] + [TestMethod] public void Zip_NeverEmpty() { var scheduler = new TestScheduler(); @@ -652,7 +655,7 @@ public void Zip_NeverEmpty() ); } - [Fact] + [TestMethod] public void Zip_EmptyNever() { var scheduler = new TestScheduler(); @@ -686,7 +689,7 @@ public void Zip_EmptyNever() #region Empty/Empty - [Fact] + [TestMethod] public void Zip_EmptyEmpty() { var scheduler = new TestScheduler(); @@ -718,7 +721,7 @@ public void Zip_EmptyEmpty() ); } - [Fact] + [TestMethod] public void Zip_Empty2() { var scheduler = new TestScheduler(); @@ -741,7 +744,7 @@ public void Zip_Empty2() } } - [Fact] + [TestMethod] public void Zip_Empty3() { var scheduler = new TestScheduler(); @@ -765,7 +768,7 @@ public void Zip_Empty3() } } - [Fact] + [TestMethod] public void Zip_Empty4() { var scheduler = new TestScheduler(); @@ -790,7 +793,7 @@ public void Zip_Empty4() } } - [Fact] + [TestMethod] public void Zip_Empty5() { var scheduler = new TestScheduler(); @@ -816,7 +819,7 @@ public void Zip_Empty5() } } - [Fact] + [TestMethod] public void Zip_Empty6() { var scheduler = new TestScheduler(); @@ -843,7 +846,7 @@ public void Zip_Empty6() } } - [Fact] + [TestMethod] public void Zip_Empty7() { var scheduler = new TestScheduler(); @@ -871,7 +874,7 @@ public void Zip_Empty7() } } - [Fact] + [TestMethod] public void Zip_Empty8() { var scheduler = new TestScheduler(); @@ -900,7 +903,7 @@ public void Zip_Empty8() } } - [Fact] + [TestMethod] public void Zip_Empty9() { var scheduler = new TestScheduler(); @@ -930,7 +933,7 @@ public void Zip_Empty9() } } - [Fact] + [TestMethod] public void Zip_Empty10() { var scheduler = new TestScheduler(); @@ -961,7 +964,7 @@ public void Zip_Empty10() } } - [Fact] + [TestMethod] public void Zip_Empty11() { var scheduler = new TestScheduler(); @@ -993,7 +996,7 @@ public void Zip_Empty11() } } - [Fact] + [TestMethod] public void Zip_Empty12() { var scheduler = new TestScheduler(); @@ -1026,7 +1029,7 @@ public void Zip_Empty12() } } - [Fact] + [TestMethod] public void Zip_Empty13() { var scheduler = new TestScheduler(); @@ -1060,7 +1063,7 @@ public void Zip_Empty13() } } - [Fact] + [TestMethod] public void Zip_Empty14() { var scheduler = new TestScheduler(); @@ -1095,7 +1098,7 @@ public void Zip_Empty14() } } - [Fact] + [TestMethod] public void Zip_Empty15() { var scheduler = new TestScheduler(); @@ -1131,7 +1134,7 @@ public void Zip_Empty15() } } - [Fact] + [TestMethod] public void Zip_Empty16() { var scheduler = new TestScheduler(); @@ -1172,7 +1175,7 @@ public void Zip_Empty16() #region Empty/Some - [Fact] + [TestMethod] public void Zip_EmptyNonEmpty() { var scheduler = new TestScheduler(); @@ -1205,7 +1208,7 @@ public void Zip_EmptyNonEmpty() ); } - [Fact] + [TestMethod] public void Zip_NonEmptyEmpty() { var scheduler = new TestScheduler(); @@ -1242,7 +1245,7 @@ public void Zip_NonEmptyEmpty() #region Never/Some - [Fact] + [TestMethod] public void Zip_NeverNonEmpty() { var scheduler = new TestScheduler(); @@ -1273,7 +1276,7 @@ public void Zip_NeverNonEmpty() ); } - [Fact] + [TestMethod] public void Zip_NonEmptyNever() { var scheduler = new TestScheduler(); @@ -1308,7 +1311,7 @@ public void Zip_NonEmptyNever() #region Some/Some - [Fact] + [TestMethod] public void Zip_NonEmptyNonEmpty() { var scheduler = new TestScheduler(); @@ -1347,7 +1350,7 @@ public void Zip_NonEmptyNonEmpty() #region Empty/Error - [Fact] + [TestMethod] public void Zip_EmptyError() { var scheduler = new TestScheduler(); @@ -1381,7 +1384,7 @@ public void Zip_EmptyError() ); } - [Fact] + [TestMethod] public void Zip_ErrorEmpty() { var scheduler = new TestScheduler(); @@ -1419,7 +1422,7 @@ public void Zip_ErrorEmpty() #region Never/Error - [Fact] + [TestMethod] public void Zip_NeverError() { var scheduler = new TestScheduler(); @@ -1452,7 +1455,7 @@ public void Zip_NeverError() ); } - [Fact] + [TestMethod] public void Zip_ErrorNever() { var scheduler = new TestScheduler(); @@ -1489,7 +1492,7 @@ public void Zip_ErrorNever() #region Error/Error - [Fact] + [TestMethod] public void Zip_ErrorError() { var scheduler = new TestScheduler(); @@ -1528,7 +1531,7 @@ public void Zip_ErrorError() #region Some/Error - [Fact] + [TestMethod] public void Zip_SomeError() { var scheduler = new TestScheduler(); @@ -1563,7 +1566,7 @@ public void Zip_SomeError() ); } - [Fact] + [TestMethod] public void Zip_ErrorSome() { var scheduler = new TestScheduler(); @@ -1602,7 +1605,7 @@ public void Zip_ErrorSome() #region Simple - [Fact] + [TestMethod] public void Zip_LeftCompletesFirst() { var scheduler = new TestScheduler(); @@ -1637,7 +1640,7 @@ public void Zip_LeftCompletesFirst() ); } - [Fact] + [TestMethod] public void Zip_RightCompletesFirst() { var scheduler = new TestScheduler(); @@ -1672,7 +1675,7 @@ public void Zip_RightCompletesFirst() ); } - [Fact] + [TestMethod] public void Zip_LeftTriggersSelectorError() { var scheduler = new TestScheduler(); @@ -1706,7 +1709,7 @@ public void Zip_LeftTriggersSelectorError() ); } - [Fact] + [TestMethod] public void Zip_RightTriggersSelectorError() { var scheduler = new TestScheduler(); @@ -1744,7 +1747,7 @@ public void Zip_RightTriggersSelectorError() #region SymmetricReturn - [Fact] + [TestMethod] public void Zip_SymmetricReturn2() { var scheduler = new TestScheduler(); @@ -1767,7 +1770,7 @@ public void Zip_SymmetricReturn2() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn3() { var scheduler = new TestScheduler(); @@ -1791,7 +1794,7 @@ public void Zip_SymmetricReturn3() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn4() { var scheduler = new TestScheduler(); @@ -1816,7 +1819,7 @@ public void Zip_SymmetricReturn4() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn5() { var scheduler = new TestScheduler(); @@ -1842,7 +1845,7 @@ public void Zip_SymmetricReturn5() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn6() { var scheduler = new TestScheduler(); @@ -1869,7 +1872,7 @@ public void Zip_SymmetricReturn6() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn7() { var scheduler = new TestScheduler(); @@ -1897,7 +1900,7 @@ public void Zip_SymmetricReturn7() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn8() { var scheduler = new TestScheduler(); @@ -1926,7 +1929,7 @@ public void Zip_SymmetricReturn8() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn9() { var scheduler = new TestScheduler(); @@ -1956,7 +1959,7 @@ public void Zip_SymmetricReturn9() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn10() { var scheduler = new TestScheduler(); @@ -1987,7 +1990,7 @@ public void Zip_SymmetricReturn10() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn11() { var scheduler = new TestScheduler(); @@ -2019,7 +2022,7 @@ public void Zip_SymmetricReturn11() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn12() { var scheduler = new TestScheduler(); @@ -2052,7 +2055,7 @@ public void Zip_SymmetricReturn12() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn13() { var scheduler = new TestScheduler(); @@ -2086,7 +2089,7 @@ public void Zip_SymmetricReturn13() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn14() { var scheduler = new TestScheduler(); @@ -2121,7 +2124,7 @@ public void Zip_SymmetricReturn14() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn15() { var scheduler = new TestScheduler(); @@ -2157,7 +2160,7 @@ public void Zip_SymmetricReturn15() } } - [Fact] + [TestMethod] public void Zip_SymmetricReturn16() { var scheduler = new TestScheduler(); @@ -2198,7 +2201,7 @@ public void Zip_SymmetricReturn16() #region Various - [Fact] + [TestMethod] public void Zip_SomeDataAsymmetric1() { var scheduler = new TestScheduler(); @@ -2227,7 +2230,7 @@ public void Zip_SomeDataAsymmetric1() } } - [Fact] + [TestMethod] public void Zip_SomeDataAsymmetric2() { var scheduler = new TestScheduler(); @@ -2256,7 +2259,7 @@ public void Zip_SomeDataAsymmetric2() } } - [Fact] + [TestMethod] public void Zip_SomeDataSymmetric() { var scheduler = new TestScheduler(); @@ -2289,7 +2292,7 @@ public void Zip_SomeDataSymmetric() #region SelectorThrows - [Fact] + [TestMethod] public void Zip_SelectorThrows() { var scheduler = new TestScheduler(); @@ -2328,7 +2331,7 @@ public void Zip_SelectorThrows() ); } - [Fact] + [TestMethod] public void Zip_SelectorThrows2() { var scheduler = new TestScheduler(); @@ -2354,7 +2357,7 @@ public void Zip_SelectorThrows2() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows3() { var scheduler = new TestScheduler(); @@ -2381,7 +2384,7 @@ public void Zip_SelectorThrows3() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows4() { var scheduler = new TestScheduler(); @@ -2409,7 +2412,7 @@ public void Zip_SelectorThrows4() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows5() { var scheduler = new TestScheduler(); @@ -2438,7 +2441,7 @@ public void Zip_SelectorThrows5() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows6() { var scheduler = new TestScheduler(); @@ -2468,7 +2471,7 @@ public void Zip_SelectorThrows6() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows7() { var scheduler = new TestScheduler(); @@ -2499,7 +2502,7 @@ public void Zip_SelectorThrows7() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows8() { var scheduler = new TestScheduler(); @@ -2531,7 +2534,7 @@ public void Zip_SelectorThrows8() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows9() { var scheduler = new TestScheduler(); @@ -2564,7 +2567,7 @@ public void Zip_SelectorThrows9() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows10() { var scheduler = new TestScheduler(); @@ -2598,7 +2601,7 @@ public void Zip_SelectorThrows10() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows11() { var scheduler = new TestScheduler(); @@ -2633,7 +2636,7 @@ public void Zip_SelectorThrows11() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows12() { var scheduler = new TestScheduler(); @@ -2669,7 +2672,7 @@ public void Zip_SelectorThrows12() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows13() { var scheduler = new TestScheduler(); @@ -2706,7 +2709,7 @@ public void Zip_SelectorThrows13() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows14() { var scheduler = new TestScheduler(); @@ -2744,7 +2747,7 @@ public void Zip_SelectorThrows14() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows15() { var scheduler = new TestScheduler(); @@ -2783,7 +2786,7 @@ public void Zip_SelectorThrows15() } } - [Fact] + [TestMethod] public void Zip_SelectorThrows16() { var scheduler = new TestScheduler(); @@ -2827,7 +2830,7 @@ public void Zip_SelectorThrows16() #region GetEnumeratorThrows - [Fact] + [TestMethod] public void Zip_GetEnumeratorThrows() { var ex = new Exception(); @@ -2858,7 +2861,7 @@ public void Zip_GetEnumeratorThrows() #region AllCompleted - [Fact] + [TestMethod] public void Zip_AllCompleted2() { var scheduler = new TestScheduler(); @@ -2888,7 +2891,7 @@ public void Zip_AllCompleted2() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted3() { var scheduler = new TestScheduler(); @@ -2919,7 +2922,7 @@ public void Zip_AllCompleted3() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted4() { var scheduler = new TestScheduler(); @@ -2951,7 +2954,7 @@ public void Zip_AllCompleted4() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted5() { var scheduler = new TestScheduler(); @@ -2984,7 +2987,7 @@ public void Zip_AllCompleted5() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted6() { var scheduler = new TestScheduler(); @@ -3018,7 +3021,7 @@ public void Zip_AllCompleted6() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted7() { var scheduler = new TestScheduler(); @@ -3053,7 +3056,7 @@ public void Zip_AllCompleted7() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted8() { var scheduler = new TestScheduler(); @@ -3089,7 +3092,7 @@ public void Zip_AllCompleted8() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted9() { var scheduler = new TestScheduler(); @@ -3126,7 +3129,7 @@ public void Zip_AllCompleted9() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted10() { var scheduler = new TestScheduler(); @@ -3164,7 +3167,7 @@ public void Zip_AllCompleted10() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted11() { var scheduler = new TestScheduler(); @@ -3203,7 +3206,7 @@ public void Zip_AllCompleted11() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted12() { var scheduler = new TestScheduler(); @@ -3243,7 +3246,7 @@ public void Zip_AllCompleted12() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted13() { var scheduler = new TestScheduler(); @@ -3284,7 +3287,7 @@ public void Zip_AllCompleted13() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted14() { var scheduler = new TestScheduler(); @@ -3326,7 +3329,7 @@ public void Zip_AllCompleted14() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted15() { var scheduler = new TestScheduler(); @@ -3369,7 +3372,7 @@ public void Zip_AllCompleted15() ); } - [Fact] + [TestMethod] public void Zip_AllCompleted16() { var scheduler = new TestScheduler(); @@ -3417,7 +3420,7 @@ public void Zip_AllCompleted16() #region ZipWithEnumerable - [Fact] + [TestMethod] public void ZipWithEnumerable_NeverNever() { var evt = new ManualResetEvent(false); @@ -3449,7 +3452,7 @@ public void ZipWithEnumerable_NeverNever() evt.Set(); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NeverEmpty() { var scheduler = new TestScheduler(); @@ -3478,7 +3481,7 @@ public void ZipWithEnumerable_NeverEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_EmptyNever() { var evt = new ManualResetEvent(false); @@ -3513,7 +3516,7 @@ public void ZipWithEnumerable_EmptyNever() evt.Set(); } - [Fact] + [TestMethod] public void ZipWithEnumerable_EmptyEmpty() { var scheduler = new TestScheduler(); @@ -3544,7 +3547,7 @@ public void ZipWithEnumerable_EmptyEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_EmptyNonEmpty() { var scheduler = new TestScheduler(); @@ -3575,7 +3578,7 @@ public void ZipWithEnumerable_EmptyNonEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NonEmptyEmpty() { var scheduler = new TestScheduler(); @@ -3607,7 +3610,7 @@ public void ZipWithEnumerable_NonEmptyEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NeverNonEmpty() { var scheduler = new TestScheduler(); @@ -3636,7 +3639,7 @@ public void ZipWithEnumerable_NeverNonEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NonEmptyNonEmpty() { var scheduler = new TestScheduler(); @@ -3669,7 +3672,7 @@ public void ZipWithEnumerable_NonEmptyNonEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_EmptyError() { var scheduler = new TestScheduler(); @@ -3702,7 +3705,7 @@ public void ZipWithEnumerable_EmptyError() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_ErrorEmpty() { var scheduler = new TestScheduler(); @@ -3735,7 +3738,7 @@ public void ZipWithEnumerable_ErrorEmpty() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NeverError() { var scheduler = new TestScheduler(); @@ -3766,7 +3769,7 @@ public void ZipWithEnumerable_NeverError() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_ErrorNever() { var evt = new ManualResetEvent(false); @@ -3803,7 +3806,7 @@ public void ZipWithEnumerable_ErrorNever() evt.Set(); } - [Fact] + [TestMethod] public void ZipWithEnumerable_ErrorError() { var scheduler = new TestScheduler(); @@ -3837,7 +3840,7 @@ public void ZipWithEnumerable_ErrorError() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_SomeError() { var scheduler = new TestScheduler(); @@ -3871,7 +3874,7 @@ public void ZipWithEnumerable_SomeError() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_ErrorSome() { var scheduler = new TestScheduler(); @@ -3904,7 +3907,7 @@ public void ZipWithEnumerable_ErrorSome() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_SomeDataBothSides() { var scheduler = new TestScheduler(); @@ -3943,7 +3946,7 @@ public void ZipWithEnumerable_SomeDataBothSides() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_EnumeratorThrowsMoveNext() { var ex = new Exception(); @@ -3978,7 +3981,7 @@ public void ZipWithEnumerable_EnumeratorThrowsMoveNext() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_EnumeratorThrowsCurrent() { var ex = new Exception(); @@ -4013,7 +4016,7 @@ public void ZipWithEnumerable_EnumeratorThrowsCurrent() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_SelectorThrows() { var scheduler = new TestScheduler(); @@ -4057,7 +4060,7 @@ public void ZipWithEnumerable_SelectorThrows() ); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NoAsyncDisposeOnMoveNext() { var source = new Subject(); @@ -4075,7 +4078,7 @@ public void ZipWithEnumerable_NoAsyncDisposeOnMoveNext() Assert.False(other.DisposedWhileCurrent); } - [Fact] + [TestMethod] public void ZipWithEnumerable_NoAsyncDisposeOnCurrent() { var source = new Subject(); @@ -4256,7 +4259,7 @@ public void Reset() #region NAry - [Fact] + [TestMethod] public void Zip_NAry_ArgumentChecking() { ReactiveAssert.Throws(() => Observable.Zip(default(IEnumerable>))); @@ -4265,7 +4268,7 @@ public void Zip_NAry_ArgumentChecking() ReactiveAssert.Throws(() => Observable.Zip(default(IObservable[]))); } - [Fact] + [TestMethod] public void Zip_NAry_Symmetric() { var scheduler = new TestScheduler(); @@ -4297,7 +4300,7 @@ public void Zip_NAry_Symmetric() ); } - [Fact] + [TestMethod] public void Zip_NAry_Symmetric_Selector() { var scheduler = new TestScheduler(); @@ -4329,7 +4332,7 @@ public void Zip_NAry_Symmetric_Selector() ); } - [Fact] + [TestMethod] public void Zip_NAry_Asymmetric() { var scheduler = new TestScheduler(); @@ -4361,7 +4364,7 @@ public void Zip_NAry_Asymmetric() ); } - [Fact] + [TestMethod] public void Zip_NAry_Asymmetric_Selector() { var scheduler = new TestScheduler(); @@ -4393,7 +4396,7 @@ public void Zip_NAry_Asymmetric_Selector() ); } - [Fact] + [TestMethod] public void Zip_NAry_Error() { var ex = new Exception(); @@ -4426,7 +4429,7 @@ public void Zip_NAry_Error() ); } - [Fact] + [TestMethod] public void Zip_NAry_Error_Selector() { var ex = new Exception(); @@ -4459,7 +4462,7 @@ public void Zip_NAry_Error_Selector() ); } - [Fact] + [TestMethod] public void Zip_NAry_Enumerable_Simple() { var scheduler = new TestScheduler(); @@ -4496,7 +4499,7 @@ public void Zip_NAry_Enumerable_Simple() ); } - [Fact] + [TestMethod] public void Zip_NAry_Enumerable_Throws() { var ex = new Exception(); @@ -4530,7 +4533,7 @@ private IEnumerable> GetSources(Exception ex, params IObservab #region AtLeastOneThrows - [Fact] + [TestMethod] public void Zip_AtLeastOneThrows4() { var ex = new Exception(); @@ -4558,7 +4561,7 @@ public void Zip_AtLeastOneThrows4() #endregion - [Fact] + [TestMethod] public void Zip2WithImmediateReturn() { Observable.Zip( @@ -4569,7 +4572,7 @@ public void Zip2WithImmediateReturn() .Subscribe(_ => { }); } - [Fact] + [TestMethod] public void Zip3WithImmediateReturn() { int result = 0; @@ -4585,7 +4588,7 @@ public void Zip3WithImmediateReturn() Assert.Equal(7, result); } - [Fact] + [TestMethod] public void ZipEnumerableWithImmediateReturn() { Enumerable.Range(0, 100) diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableRemotingTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableRemotingTest.cs index c5dc35a6c3..e3cf3eebc9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableRemotingTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableRemotingTest.cs @@ -10,14 +10,16 @@ using System.Runtime.Remoting.Lifetime; using System.Threading; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { - + [TestClass] public partial class ObservableRemotingTest : ReactiveTest { - [Fact] + [TestMethod] public void Remotable_ArgumentChecking() { ReactiveAssert.Throws(() => RemotingObservable.Remotable(default(IObservable))); @@ -102,7 +104,7 @@ public void Unregister(ISponsor obj) } } - [Fact] + [TestMethod] public void Remotable_Empty() { var evt = new ManualResetEvent(false); @@ -114,7 +116,7 @@ public void Remotable_Empty() } } - [Fact] + [TestMethod] public void Remotable_Return() { var evt = new ManualResetEvent(false); @@ -128,7 +130,7 @@ public void Remotable_Return() } } - [Fact] + [TestMethod] public void Remotable_Return_LongLease() { var evt = new ManualResetEvent(false); @@ -142,7 +144,7 @@ public void Remotable_Return_LongLease() } } - [Fact] + [TestMethod] public void Remotable_Throw() { var ex = new InvalidOperationException("Oops!"); @@ -158,7 +160,7 @@ public void Remotable_Throw() } } - [Fact] + [TestMethod] public void Remotable_Disposal() { var test = GetRemoteTestObject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableSafetyTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableSafetyTest.cs index 354223ec1f..cec930ec17 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableSafetyTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/ObservableSafetyTest.cs @@ -8,21 +8,23 @@ 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 partial class ObservableSafetyTest : ReactiveTest { - [Fact] + [TestMethod] public void SubscribeSafe_ArgumentChecking() { ReactiveAssert.Throws(() => ObservableExtensions.SubscribeSafe(default, Observer.Create(_ => { }))); ReactiveAssert.Throws(() => ObservableExtensions.SubscribeSafe(Observable.Return(42), default)); } - [Fact] + [TestMethod] public void Safety_Subscription1() { var ex = new Exception(); @@ -38,7 +40,7 @@ public void Safety_Subscription1() d.Dispose(); } - [Fact] + [TestMethod] public void Safety_Subscription2() { var ex = new Exception(); @@ -83,7 +85,7 @@ public IDisposable Subscribe(IObserver observer) } } - [Fact] + [TestMethod] public void ObservableBase_ObserverThrows() { var ex = new Exception(); @@ -122,7 +124,7 @@ public void ObservableBase_ObserverThrows() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void ObservableBase_ObserverThrows_CustomObserver() { var ex = new Exception(); @@ -158,7 +160,7 @@ public void ObservableBase_ObserverThrows_CustomObserver() Assert.Same(ex, err); } - [Fact] + [TestMethod] public void Producer_ObserverThrows() { var ex = new Exception(); @@ -211,7 +213,7 @@ public void Producer_ObserverThrows() ); } - [Fact] + [TestMethod] public void Producer_ObserverThrows_CustomObserver() { var ex = new Exception(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableExTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableExTest.cs index d9d8003e99..a8ad5729d7 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableExTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableExTest.cs @@ -7,18 +7,18 @@ using System.Linq.Expressions; using System.Reactive.Linq; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace ReactiveTests.Tests { - + [TestClass] public class QbservableExTest : ReactiveTest { private readonly IQbservable _qbNull = null; private IQbservable _qbMy = new MyQbservable(); private IQbservableProvider _qbp = new MyQbservableProvider(); - [Fact] + [TestMethod] public void ForkJoin_ArgumentNullChecks() { ReactiveAssert.Throws(() => QbservableEx.ForkJoin(_qbNull, _qbMy, (a, b) => a + b)); @@ -30,7 +30,7 @@ public void ForkJoin_ArgumentNullChecks() ReactiveAssert.Throws(() => QbservableEx.ForkJoin(_qbp, default(IQueryable>))); } - [Fact] + [TestMethod] public void ForkJoin() { _qbMy.ForkJoin(_qbMy, (a, b) => a + b); @@ -38,7 +38,7 @@ public void ForkJoin() _qbp.ForkJoin(new MyQueryable>()); } - [Fact] + [TestMethod] public void Create_ArgumentNullChecks() { ReactiveAssert.Throws(() => QbservableEx.Create(default, _ => new IObservable[0])); @@ -47,21 +47,21 @@ public void Create_ArgumentNullChecks() ReactiveAssert.Throws(() => QbservableEx.Create(_qbp, null)); } - [Fact] + [TestMethod] public void Create() { _qbp.Create(obs => new IObservable[0]); _qbp.Create(() => new IObservable[0]); } - [Fact] + [TestMethod] public void Let_ArgumentNullChecks() { ReactiveAssert.Throws(() => QbservableEx.Let(_qbNull, xs => xs)); ReactiveAssert.Throws(() => QbservableEx.Let(_qbMy, default(Expression, IObservable>>))); } - [Fact] + [TestMethod] public void Let() { _qbMy.Let(xs => xs); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableTest.cs index 33c59cc7b8..da146f43f9 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/QbservableTest.cs @@ -17,18 +17,20 @@ using System.Runtime.CompilerServices; using System.Threading; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { - + [TestClass] public class QbservableTest { private readonly IQbservable _qbNull = null; private IQbservable _qbMy = new MyQbservable(); private IQbservableProvider _qbp = new MyQbservableProvider(); - [Fact] + [TestMethod] public void LocalQueryMethodImplementationTypeAttribute() { var t = typeof(string); @@ -38,7 +40,7 @@ public void LocalQueryMethodImplementationTypeAttribute() Assert.Same(t, attr.TargetType); } - [Fact] + [TestMethod] public void Aggregate_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Aggregate(_qbNull, (a, b) => a + b)); @@ -47,27 +49,27 @@ public void Aggregate_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Aggregate(_qbMy, 1, null)); } - [Fact] + [TestMethod] public void Aggregate() { _qbMy.Aggregate((a, b) => a + b); _qbMy.Aggregate("", (a, b) => a + b); } - [Fact] + [TestMethod] public void All_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.All(_qbNull, a => true)); ReactiveAssert.Throws(() => Qbservable.All(_qbMy, null)); } - [Fact] + [TestMethod] public void All() { _qbMy.All(a => true); } - [Fact] + [TestMethod] public void Amb_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Amb(_qbNull, _qbMy)); @@ -78,7 +80,7 @@ public void Amb_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Amb(_qbp, default(IQueryable>))); } - [Fact] + [TestMethod] public void Amb() { _qbMy.Amb(_qbMy); @@ -86,7 +88,7 @@ public void Amb() _qbp.Amb(new MyQueryable>()); } - [Fact] + [TestMethod] public void And_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.And(_qbNull, _qbMy)); @@ -107,13 +109,13 @@ public void And_ArgumentNullChecks() ReactiveAssert.Throws(() => _qbMy.And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbNull)); } - [Fact] + [TestMethod] public void And() { _qbMy.And(_qbMy); } - [Fact] + [TestMethod] public void Any_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Any(_qbNull)); @@ -121,14 +123,14 @@ public void Any_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Any(_qbMy, null)); } - [Fact] + [TestMethod] public void Any() { _qbMy.Any(); _qbMy.Any(a => true); } - [Fact] + [TestMethod] public void Average_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Average(default(IQbservable))); @@ -143,7 +145,7 @@ public void Average_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Average(default(IQbservable))); } - [Fact] + [TestMethod] public void Average() { new MyQbservable().Average(); @@ -158,21 +160,21 @@ public void Average() new MyQbservable().Average(); } - [Fact] + [TestMethod] public void BufferWithCount_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Window(_qbNull, 1)); ReactiveAssert.Throws(() => Qbservable.Window(_qbNull, 1, 1)); } - [Fact] + [TestMethod] public void BufferWithCount() { _qbMy.Window(1); _qbMy.Window(1, 1); } - [Fact] + [TestMethod] public void BufferWithTime_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Buffer(_qbNull, TimeSpan.Zero)); @@ -183,7 +185,7 @@ public void BufferWithTime_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Buffer(_qbMy, TimeSpan.Zero, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void BufferWithTime() { _qbMy.Buffer(TimeSpan.Zero); @@ -192,7 +194,7 @@ public void BufferWithTime() _qbMy.Buffer(TimeSpan.Zero, TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Case_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Case(null, () => 1, new Dictionary>())); @@ -210,7 +212,7 @@ public void Case_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Case(_qbp, () => 1, new Dictionary>(), default(IQbservable))); } - [Fact] + [TestMethod] public void Case() { _qbp.Case(() => 1, new Dictionary>()); @@ -218,19 +220,19 @@ public void Case() _qbp.Case(() => 1, new Dictionary>(), _qbMy); } - [Fact] + [TestMethod] public void Cast_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Cast(default(MyQbservable))); } - [Fact] + [TestMethod] public void Cast() { Qbservable.Cast(new MyQbservable()); } - [Fact] + [TestMethod] public void Catch_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Catch(_qbMy, null)); @@ -243,7 +245,7 @@ public void Catch_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Catch(_qbp, default(IQueryable>))); } - [Fact] + [TestMethod] public void Catch() { _qbMy.Catch((Exception ex) => _qbMy); @@ -252,7 +254,7 @@ public void Catch() _qbp.Catch(new MyQueryable>()); } - [Fact] + [TestMethod] public void CombineLatest_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.CombineLatest(_qbNull, _qbMy, (a, b) => a + b)); @@ -260,13 +262,13 @@ public void CombineLatest_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.CombineLatest(_qbMy, _qbMy, default(Expression>))); } - [Fact] + [TestMethod] public void CombineLatest() { _qbMy.CombineLatest(_qbMy, (a, b) => a + b); } - [Fact] + [TestMethod] public void Contains_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Contains(_qbNull, 1)); @@ -274,26 +276,26 @@ public void Contains_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Contains(_qbMy, 1, null)); } - [Fact] + [TestMethod] public void Contains() { _qbMy.Contains(1); _qbMy.Contains(1, EqualityComparer.Default); } - [Fact] + [TestMethod] public void Count_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Count(_qbNull)); } - [Fact] + [TestMethod] public void Count() { _qbMy.Count(); } - [Fact] + [TestMethod] public void Concat_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Concat(_qbNull, _qbMy)); @@ -304,7 +306,7 @@ public void Concat_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Concat(_qbp, default(IQueryable>))); } - [Fact] + [TestMethod] public void Concat() { _qbMy.Concat(_qbMy); @@ -312,46 +314,46 @@ public void Concat() _qbp.Concat(new MyQueryable>()); } - [Fact] + [TestMethod] public void Create_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Create(null, o => default(Action))); ReactiveAssert.Throws(() => Qbservable.Create(_qbp, default(Expression, Action>>))); } - [Fact] + [TestMethod] public void Create() { _qbp.Create(o => default(Action)); } - [Fact] + [TestMethod] public void CreateWithDisposable_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Create(null, o => default(IDisposable))); ReactiveAssert.Throws(() => Qbservable.Create(_qbp, default(Expression, IDisposable>>))); } - [Fact] + [TestMethod] public void CreateWithDisposable() { _qbp.Create(o => default(IDisposable)); } - [Fact] + [TestMethod] public void Defer_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Defer(null, () => _qbMy)); ReactiveAssert.Throws(() => Qbservable.Defer(_qbp, default(Expression>>))); } - [Fact] + [TestMethod] public void Defer() { _qbp.Defer(() => _qbMy); } - [Fact] + [TestMethod] public void Delay_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Delay(_qbNull, DateTimeOffset.Now)); @@ -362,7 +364,7 @@ public void Delay_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Delay(_qbMy, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Delay() { _qbMy.Delay(DateTimeOffset.Now); @@ -371,19 +373,19 @@ public void Delay() _qbMy.Delay(TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Dematerialize_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Dematerialize(default(IQbservable>))); } - [Fact] + [TestMethod] public void Dematerialize() { new MyQbservable>().Dematerialize(); } - [Fact] + [TestMethod] public void DistinctUntilChanged_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.DistinctUntilChanged(_qbNull)); @@ -396,7 +398,7 @@ public void DistinctUntilChanged_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.DistinctUntilChanged(_qbMy, a => a, default)); } - [Fact] + [TestMethod] public void DistinctUntilChanged() { _qbMy.DistinctUntilChanged(); @@ -405,7 +407,7 @@ public void DistinctUntilChanged() _qbMy.DistinctUntilChanged(a => a, EqualityComparer.Default); } - [Fact] + [TestMethod] public void Do_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Do(_qbNull, i => Debug.WriteLine(i))); @@ -428,7 +430,7 @@ public void Do_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Do(_qbMy, default(IObserver))); } - [Fact] + [TestMethod] public void Do() { _qbMy.Do(i => Debug.WriteLine(i)); @@ -438,20 +440,20 @@ public void Do() _qbMy.Do(Observer.Create(i => Debug.WriteLine(i))); } - [Fact] + [TestMethod] public void DoWhile_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.DoWhile(_qbNull, () => true)); ReactiveAssert.Throws(() => Qbservable.DoWhile(_qbMy, null)); } - [Fact] + [TestMethod] public void DoWhile() { _qbMy.DoWhile(() => true); } - [Fact] + [TestMethod] public void Empty_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Empty(null)); @@ -459,27 +461,27 @@ public void Empty_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Empty(null, Scheduler.Immediate)); } - [Fact] + [TestMethod] public void Empty() { _qbp.Empty(); _qbp.Empty(Scheduler.Immediate); } - [Fact] + [TestMethod] public void Finally_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Finally(_qbNull, () => Debug.WriteLine(""))); ReactiveAssert.Throws(() => Qbservable.Finally(_qbMy, null)); } - [Fact] + [TestMethod] public void Finally() { _qbMy.Finally(() => Debug.WriteLine("")); } - [Fact] + [TestMethod] public void For_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.For(null, new[] { 1 }, i => _qbMy)); @@ -487,13 +489,13 @@ public void For_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.For(_qbp, new[] { 1 }, default(Expression>>))); } - [Fact] + [TestMethod] public void For() { _qbp.For(new[] { 1 }, i => _qbMy); } - [Fact] + [TestMethod] public void FromEvent_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.FromEventPattern(null, "", "Event")); @@ -511,7 +513,7 @@ public void FromEvent_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.FromEventPattern(null, e => Debug.WriteLine(""), e => Debug.WriteLine(""))); } - [Fact] + [TestMethod] public void FromEvent() { _qbp.FromEventPattern("", "Event"); @@ -520,7 +522,7 @@ public void FromEvent() _qbp.FromEventPattern(e => Debug.WriteLine(""), e => Debug.WriteLine("")); } - [Fact] + [TestMethod] public void Generate_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Generate(null, 1, i => true, i => i + 1, i => i)); @@ -534,14 +536,14 @@ public void Generate_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Generate(_qbp, 1, i => true, i => i + 1, i => i, default(IScheduler))); } - [Fact] + [TestMethod] public void Generate() { _qbp.Generate(1, i => true, i => i + 1, i => i); _qbp.Generate(1, i => true, i => i + 1, i => i, Scheduler.Immediate); } - [Fact] + [TestMethod] public void GenerateWithTime_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Generate(null, 1, i => true, i => i + 1, i => i, i => DateTimeOffset.Now)); @@ -569,7 +571,7 @@ public void GenerateWithTime_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Generate(_qbp, 1, i => true, i => i + 1, i => i, i => TimeSpan.Zero, null)); } - [Fact] + [TestMethod] public void GenerateWithTime() { _qbp.Generate(1, i => true, i => i + 1, i => i, i => DateTimeOffset.Now); @@ -578,7 +580,7 @@ public void GenerateWithTime() _qbp.Generate(1, i => true, i => i + 1, i => i, i => TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void GroupBy_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.GroupBy(_qbNull, x => x)); @@ -595,7 +597,7 @@ public void GroupBy_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.GroupBy(_qbMy, x => x, x => x, default(IEqualityComparer))); } - [Fact] + [TestMethod] public void GroupBy() { _qbMy.GroupBy(x => (double)x); @@ -604,7 +606,7 @@ public void GroupBy() _qbMy.GroupBy(x => x, x => x.ToString(), EqualityComparer.Default); } - [Fact] + [TestMethod] public void If_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.If(null, () => true, _qbMy, _qbMy)); @@ -613,13 +615,13 @@ public void If_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.If(_qbp, () => true, _qbMy, _qbNull)); } - [Fact] + [TestMethod] public void If() { _qbp.If(() => true, _qbMy, _qbMy); } - [Fact] + [TestMethod] public void Interval_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Interval(null, TimeSpan.Zero)); @@ -627,63 +629,63 @@ public void Interval_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Interval(_qbp, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Interval() { _qbp.Interval(TimeSpan.Zero); _qbp.Interval(TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void IsEmpty_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.IsEmpty(_qbNull)); } - [Fact] + [TestMethod] public void IsEmpty() { _qbMy.IsEmpty(); } - [Fact] + [TestMethod] public void Latest_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Latest(_qbNull)); } - [Fact] + [TestMethod] public void Latest() { ReactiveAssert.Throws(() => _qbMy.Latest()); new MyQbservableQueryable().Latest(); } - [Fact] + [TestMethod] public void LongCount_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.LongCount(_qbNull)); } - [Fact] + [TestMethod] public void LongCount() { _qbMy.LongCount(); } - [Fact] + [TestMethod] public void Materialize_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Materialize(_qbNull)); } - [Fact] + [TestMethod] public void Materialize() { _qbMy.Materialize(); } - [Fact] + [TestMethod] public void Max_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Max(null)); @@ -701,7 +703,7 @@ public void Max_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Max(default(IQbservable))); } - [Fact] + [TestMethod] public void Max() { new MyQbservable().Max(); @@ -718,7 +720,7 @@ public void Max() new MyQbservable().Max(); } - [Fact] + [TestMethod] public void MaxBy_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.MaxBy(default(IQbservable), s => s.Length)); @@ -728,14 +730,14 @@ public void MaxBy_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.MaxBy(new MyQbservable(), s => s.Length, default)); } - [Fact] + [TestMethod] public void MaxBy() { new MyQbservable().MaxBy(s => s.Length); new MyQbservable().MaxBy(s => s.Length, Comparer.Default); } - [Fact] + [TestMethod] public void Merge_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Merge(_qbNull, _qbMy)); @@ -756,7 +758,7 @@ public void Merge_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Merge(_qbp, default(IQueryable>), Scheduler.Immediate)); } - [Fact] + [TestMethod] public void Merge() { _qbMy.Merge(_qbMy); @@ -768,7 +770,7 @@ public void Merge() _qbp.Merge(new MyQueryable>(), Scheduler.Immediate); } - [Fact] + [TestMethod] public void Min_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Min(null)); @@ -786,7 +788,7 @@ public void Min_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Min(default(IQbservable))); } - [Fact] + [TestMethod] public void Min() { new MyQbservable().Min(); @@ -803,7 +805,7 @@ public void Min() new MyQbservable().Min(); } - [Fact] + [TestMethod] public void MinBy_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.MinBy(default(IQbservable), s => s.Length)); @@ -813,52 +815,52 @@ public void MinBy_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.MinBy(new MyQbservable(), s => s.Length, default)); } - [Fact] + [TestMethod] public void MinBy() { new MyQbservable().MinBy(s => s.Length); new MyQbservable().MinBy(s => s.Length, Comparer.Default); } - [Fact] + [TestMethod] public void MostRecent_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.MostRecent(_qbNull, 1)); } - [Fact] + [TestMethod] public void MostRecent() { ReactiveAssert.Throws(() => _qbMy.MostRecent(1)); new MyQbservableQueryable().MostRecent(1); } - [Fact] + [TestMethod] public void Never_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Never(null)); } - [Fact] + [TestMethod] public void Never() { _qbp.Never(); } - [Fact] + [TestMethod] public void Next_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Next(_qbNull)); } - [Fact] + [TestMethod] public void Next() { ReactiveAssert.Throws(() => _qbMy.Next()); new MyQbservableQueryable().Next(); } - [Fact] + [TestMethod] public void ObserveOn_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.ObserveOn(_qbMy, default(IScheduler))); @@ -878,7 +880,7 @@ public void ObserveOn_ArgumentNullChecks() } #if HAS_DISPATCHER - [Fact] + [TestMethod] public void ObserveOn() { _qbMy.ObserveOn(Scheduler.Immediate); @@ -887,19 +889,19 @@ public void ObserveOn() } #endif - [Fact] + [TestMethod] public void OfType_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.OfType(default(MyQbservable))); } - [Fact] + [TestMethod] public void OfType() { Qbservable.OfType(new MyQbservable()); } - [Fact] + [TestMethod] public void OnErrorResumeNext_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.OnErrorResumeNext(_qbNull, _qbMy)); @@ -910,7 +912,7 @@ public void OnErrorResumeNext_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.OnErrorResumeNext(_qbp, default(IQueryable>))); } - [Fact] + [TestMethod] public void OnErrorResumeNext() { _qbMy.OnErrorResumeNext(_qbMy); @@ -919,7 +921,7 @@ public void OnErrorResumeNext() } - [Fact] + [TestMethod] public void Range_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Range(null, 0, 10)); @@ -927,27 +929,27 @@ public void Range_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Range(_qbp, 0, 10, default)); } - [Fact] + [TestMethod] public void Range() { _qbp.Range(0, 10); _qbp.Range(0, 10, Scheduler.Immediate); } - [Fact] + [TestMethod] public void RefCount_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.RefCount(null, Observable.Return(1).Multicast(new ReplaySubject()))); ReactiveAssert.Throws(() => Qbservable.RefCount(_qbp, default(IConnectableObservable))); } - [Fact] + [TestMethod] public void RefCount() { _qbp.RefCount(Observable.Return(1).Multicast(new ReplaySubject())); } - [Fact] + [TestMethod] public void Repeat_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Repeat(null, 0)); @@ -960,7 +962,7 @@ public void Repeat_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Repeat(_qbNull, 1)); } - [Fact] + [TestMethod] public void Repeat() { _qbMy.Repeat(); @@ -970,21 +972,21 @@ public void Repeat() _qbp.Repeat(42, Scheduler.Immediate); _qbp.Repeat(42, 1, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Retry_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Retry(_qbNull)); ReactiveAssert.Throws(() => Qbservable.Retry(_qbNull, 1)); } - [Fact] + [TestMethod] public void Retry() { _qbMy.Retry(); _qbMy.Retry(1); } - [Fact] + [TestMethod] public void Return_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Return(null, 1)); @@ -992,14 +994,14 @@ public void Return_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Return(_qbp, 1, default)); } - [Fact] + [TestMethod] public void Return() { _qbp.Return(1); _qbp.Return(1, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Sample_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Sample(_qbNull, TimeSpan.Zero)); @@ -1007,14 +1009,14 @@ public void Sample_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Sample(_qbMy, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Sample() { _qbMy.Sample(TimeSpan.Zero); _qbMy.Sample(TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Scan_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Scan(_qbNull, (a, b) => a + b)); @@ -1023,14 +1025,14 @@ public void Scan_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Scan(_qbMy, 1, null)); } - [Fact] + [TestMethod] public void Scan() { _qbMy.Scan((a, b) => a + b); _qbMy.Scan("", (a, b) => a + b); } - [Fact] + [TestMethod] public void Select_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Select(_qbNull, x => x)); @@ -1039,14 +1041,14 @@ public void Select_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Select(_qbMy, default(Expression>))); } - [Fact] + [TestMethod] public void Select() { _qbMy.Select(x => x + 1); _qbMy.Select((x, i) => x + i); } - [Fact] + [TestMethod] public void SelectMany_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.SelectMany(_qbNull, x => new[] { "" })); @@ -1068,7 +1070,7 @@ public void SelectMany_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.SelectMany(_qbMy, x => Observable.Return(""), x => Observable.Return(""), default)); } - [Fact] + [TestMethod] public void SelectMany() { _qbMy.SelectMany(x => new[] { "" }); @@ -1078,57 +1080,57 @@ public void SelectMany() _qbMy.SelectMany(x => Observable.Return(""), x => Observable.Return(""), () => Observable.Return("")); } - [Fact] + [TestMethod] public void Skip_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Skip(_qbNull, 1)); } - [Fact] + [TestMethod] public void Skip() { _qbMy.Skip(1); } - [Fact] + [TestMethod] public void SkipLast_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.SkipLast(_qbNull, 1)); } - [Fact] + [TestMethod] public void SkipLast() { _qbMy.SkipLast(1); } - [Fact] + [TestMethod] public void SkipUntil_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.SkipUntil(_qbNull, _qbMy)); ReactiveAssert.Throws(() => Qbservable.SkipUntil(_qbMy, _qbNull)); } - [Fact] + [TestMethod] public void SkipUntil() { _qbMy.SkipUntil(_qbMy); } - [Fact] + [TestMethod] public void SkipWhile_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.SkipWhile(_qbNull, x => true)); ReactiveAssert.Throws(() => Qbservable.SkipWhile(_qbMy, default(Expression>))); } - [Fact] + [TestMethod] public void SkipWhile() { _qbMy.SkipWhile(x => true); } - [Fact] + [TestMethod] public void StartWith_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.StartWith(_qbNull, new[] { 1 })); @@ -1138,14 +1140,14 @@ public void StartWith_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.StartWith(_qbMy, Scheduler.Immediate, default)); } - [Fact] + [TestMethod] public void StartWith() { Ignore(_qbMy.StartWith(1, 2, 3)); Ignore(_qbMy.StartWith(Scheduler.Immediate, 1, 2, 3)); } - [Fact] + [TestMethod] public void SubscribeOn_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.SubscribeOn(_qbMy, default(IScheduler))); @@ -1164,7 +1166,7 @@ public void SubscribeOn_ArgumentNullChecks() #endif } - [Fact] + [TestMethod] public void SubscribeOn() { _qbMy.SubscribeOn(Scheduler.Immediate); @@ -1177,7 +1179,7 @@ public void SubscribeOn() #endif } - [Fact] + [TestMethod] public void Sum_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Sum(default(IQbservable))); @@ -1192,7 +1194,7 @@ public void Sum_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Sum(default(IQbservable))); } - [Fact] + [TestMethod] public void Sum() { new MyQbservable().Sum(); @@ -1207,19 +1209,19 @@ public void Sum() new MyQbservable().Sum(); } - [Fact] + [TestMethod] public void Switch_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Switch(default(IQbservable>))); } - [Fact] + [TestMethod] public void Switch() { new MyQbservable>().Switch(); } - [Fact] + [TestMethod] public void Synchronize_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Synchronize(_qbNull)); @@ -1227,64 +1229,64 @@ public void Synchronize_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Synchronize(_qbMy, null)); } - [Fact] + [TestMethod] public void Synchronize() { _qbMy.Synchronize(); _qbMy.Synchronize(""); } - [Fact] + [TestMethod] public void Take_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Take(_qbNull, 1)); } - [Fact] + [TestMethod] public void Take() { _qbMy.Take(1); } - [Fact] + [TestMethod] public void TakeLast_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.TakeLast(_qbNull, 1)); } - [Fact] + [TestMethod] public void TakeLast() { _qbMy.TakeLast(1); } - [Fact] + [TestMethod] public void TakeUntil_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.TakeUntil(_qbNull, _qbMy)); ReactiveAssert.Throws(() => Qbservable.TakeUntil(_qbMy, _qbNull)); } - [Fact] + [TestMethod] public void TakeUntil() { _qbMy.TakeUntil(_qbMy); } - [Fact] + [TestMethod] public void TakeWhile_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.TakeWhile(_qbNull, x => true)); ReactiveAssert.Throws(() => Qbservable.TakeWhile(_qbMy, default(Expression>))); } - [Fact] + [TestMethod] public void TakeWhile() { _qbMy.TakeWhile(x => true); } - [Fact] + [TestMethod] public void Throttle_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Throttle(_qbNull, TimeSpan.Zero)); @@ -1292,14 +1294,14 @@ public void Throttle_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Throttle(_qbMy, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Throttle() { _qbMy.Throttle(TimeSpan.Zero); _qbMy.Throttle(TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Throw_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Throw(null, new Exception())); @@ -1309,14 +1311,14 @@ public void Throw_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Throw(_qbp, new Exception(), default(IScheduler))); } - [Fact] + [TestMethod] public void Throw() { _qbp.Throw(new Exception()); _qbp.Throw(new Exception(), Scheduler.Immediate); } - [Fact] + [TestMethod] public void TimeInterval_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.TimeInterval(_qbNull)); @@ -1324,14 +1326,14 @@ public void TimeInterval_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.TimeInterval(_qbMy, default)); } - [Fact] + [TestMethod] public void TimeInterval() { _qbMy.TimeInterval(); _qbMy.TimeInterval(Scheduler.Immediate); } - [Fact] + [TestMethod] public void Timeout_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Timeout(_qbNull, DateTimeOffset.Now)); @@ -1355,7 +1357,7 @@ public void Timeout_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Timeout(_qbMy, TimeSpan.Zero, _qbMy, default)); } - [Fact] + [TestMethod] public void Timeout() { _qbMy.Timeout(DateTimeOffset.Now); @@ -1368,7 +1370,7 @@ public void Timeout() _qbMy.Timeout(TimeSpan.Zero, _qbMy, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Timer_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Timer(null, DateTimeOffset.Now)); @@ -1388,7 +1390,7 @@ public void Timer_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Timer(_qbp, TimeSpan.Zero, TimeSpan.Zero, default)); } - [Fact] + [TestMethod] public void Timer() { _qbp.Timer(DateTimeOffset.Now); @@ -1401,7 +1403,7 @@ public void Timer() _qbp.Timer(TimeSpan.Zero, TimeSpan.Zero, Scheduler.Immediate); } - [Fact] + [TestMethod] public void Timestamp_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Timestamp(_qbNull)); @@ -1409,14 +1411,14 @@ public void Timestamp_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Timestamp(_qbMy, default)); } - [Fact] + [TestMethod] public void Timestamp() { _qbMy.Timestamp(); _qbMy.Timestamp(Scheduler.Immediate); } - [Fact] + [TestMethod] public void ToObservable_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.ToObservable(null, new[] { 1 })); @@ -1426,40 +1428,40 @@ public void ToObservable_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.ToObservable(_qbp, new[] { 1 }, default)); } - [Fact] + [TestMethod] public void ToObservable() { _qbp.ToObservable(new[] { 1 }); _qbp.ToObservable(new[] { 1 }, Scheduler.Immediate); } - [Fact] + [TestMethod] public void ToQueryable_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.ToQueryable(_qbNull)); } - [Fact] + [TestMethod] public void ToQueryable() { ReactiveAssert.Throws(() => _qbMy.ToQueryable()); new MyQbservableQueryable().ToQueryable(); } - [Fact] + [TestMethod] public void ToQbservable_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.ToQbservable(default(IQueryable))); } - [Fact] + [TestMethod] public void ToQbservable() { ReactiveAssert.Throws(() => new[] { 1 }.AsQueryable().ToQbservable()); new MyQueryable().ToQbservable(); } - [Fact] + [TestMethod] public void Using_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Using(null, () => new MyDisposable(), x => Observable.Return(x.ToString()))); @@ -1475,13 +1477,13 @@ public void Dispose() } } - [Fact] + [TestMethod] public void Using() { _qbp.Using(() => new MyDisposable(), x => Observable.Return(x.ToString())); } - [Fact] + [TestMethod] public void Where_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Where(_qbNull, x => true)); @@ -1490,14 +1492,14 @@ public void Where_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Where(_qbMy, default(Expression>))); } - [Fact] + [TestMethod] public void Where() { _qbMy.Where(x => true); _qbMy.Where((x, i) => true); } - [Fact] + [TestMethod] public void While_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.While(null, () => true, _qbMy)); @@ -1505,13 +1507,13 @@ public void While_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.While(_qbp, () => true, _qbNull)); } - [Fact] + [TestMethod] public void While() { _qbp.While(() => true, _qbMy); } - [Fact] + [TestMethod] public void WithLatestFrom_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.WithLatestFrom(_qbNull, _qbMy, (a, b) => a + b)); @@ -1519,13 +1521,13 @@ public void WithLatestFrom_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.WithLatestFrom(_qbMy, _qbMy, default(Expression>))); } - [Fact] + [TestMethod] public void WithLatestFrom() { _qbMy.WithLatestFrom(_qbMy, (a, b) => a + b); } - [Fact] + [TestMethod] public void Zip_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Zip(_qbNull, _qbMy, (a, b) => a + b)); @@ -1536,26 +1538,26 @@ public void Zip_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.Zip(_qbMy, new[] { 1 }, default(Expression>))); } - [Fact] + [TestMethod] public void Zip() { _qbMy.Zip(_qbMy, (a, b) => a + b); _qbMy.Zip(new[] { 1 }, (a, b) => a + b); } - [Fact] + [TestMethod] public void AsObservable_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.AsObservable(_qbNull)); } - [Fact] + [TestMethod] public void AsObservable() { Assert.Same(_qbMy.AsObservable(), _qbMy); } - [Fact] + [TestMethod] public void Join_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.When(null, _qbMy.Then(x => x))); @@ -1564,7 +1566,7 @@ public void Join_ArgumentNullChecks() ReactiveAssert.Throws(() => Qbservable.When(_qbp, default(IQueryable>))); } - [Fact] + [TestMethod] public void Join() { _qbp.When(new MyQueryable>()); @@ -1589,7 +1591,7 @@ public void Join() ); } - [Fact] + [TestMethod] public void Then_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.Then(_qbNull, default(Expression>))); @@ -1611,13 +1613,13 @@ public void Then_ArgumentNullChecks() ReactiveAssert.Throws(() => _qbMy.And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).And(_qbMy).Then(default(Expression>))); } - [Fact] + [TestMethod] public void AsQbservable_ArgumentNullChecks() { ReactiveAssert.Throws(() => Qbservable.AsQbservable(null)); } - [Fact] + [TestMethod] public void AsQbservable_CreateQuery_ArgumentChecks() { var xs = Observable.Return(1).AsQbservable(); @@ -1625,7 +1627,7 @@ public void AsQbservable_CreateQuery_ArgumentChecks() ReactiveAssert.Throws(() => xs.Provider.CreateQuery(Expression.Constant(1))); } - [Fact] + [TestMethod] public void AsQbservable_ToString() { var xs = Observable.Return(1); @@ -1643,7 +1645,7 @@ public void AsQbservable_ToString() Assert.Equal(ws.Expression.ToString(), ws.ToString()); } - [Fact] + [TestMethod] public void Qbservable_Subscribe_Source() { var xs = Observable.Return(1).AsQbservable(); @@ -1652,7 +1654,7 @@ public void Qbservable_Subscribe_Source() Assert.Equal(_x, 1); } - [Fact] + [TestMethod] public void Qbservable_VariousOperators() { var xs = Observable.Return(1).AsQbservable(); @@ -1672,7 +1674,7 @@ public void Qbservable_VariousOperators() // TODO: IQueryable ones } - [Fact] + [TestMethod] public void Qbservable_ProviderOperators() { var xs = Observable.Return(1).AsQbservable(); @@ -1687,7 +1689,7 @@ private class MyException : Exception { } - [Fact] + [TestMethod] public void Qbservable_JoinPatterns() { var xs = Observable.Return(1).AsQbservable(); @@ -1698,7 +1700,7 @@ public void Qbservable_JoinPatterns() Assert.True(Qbservable.Provider.When(xs.And(ys).And(zs).Then((x, y, z) => x + y + z)).ToEnumerable().SequenceEqual(new[] { 6 }), "Join"); } - [Fact] + [TestMethod] public void Qbservable_MoreProviderFun() { Assert.True( @@ -1713,7 +1715,7 @@ public void Qbservable_MoreProviderFun() ); } - [Fact] + [TestMethod] public void Qbservable_AsQbservable_ToQueryable() { var xs = Observable.Range(0, 10).Where(x => x > 5).AsQbservable().Select(x => x + 1); @@ -1722,7 +1724,7 @@ public void Qbservable_AsQbservable_ToQueryable() Assert.True(ys.SequenceEqual(new[] { 10, 9, 8, 7 })); } - [Fact] + [TestMethod] public void Qbservable_AsQbservable_ToQueryable_Errors() { var provider = (IQueryProvider)Qbservable.Provider; @@ -1736,7 +1738,7 @@ public void Qbservable_AsQbservable_ToQueryable_Errors() ReactiveAssert.Throws(() => provider.CreateQuery(Qbservable.Provider.Return(1).Expression)); } - [Fact] + [TestMethod] public void Qbservable_TwoProviders_Amb() { var xs = Observable.Return(1).AsQbservable(); @@ -1751,7 +1753,7 @@ private void Ignore(IQbservable q) { } - [Fact] + [TestMethod] public void Qbservable_Observable_Parity() { var obs = typeof(Observable).GetMethods(BindingFlags.Public | BindingFlags.Static).ToList(); @@ -1860,7 +1862,7 @@ public static string GetTypeName(Type t, bool correct) return t.Name; } - [Fact] + [TestMethod] public void Qbservable_Extensibility_Combinator() { var res1 = Observable.Return(42).AsQbservable().Foo(x => x / 2).AsObservable().Single(); @@ -1871,14 +1873,14 @@ public void Qbservable_Extensibility_Combinator() } #if !CRIPPLED_REFLECTION - [Fact] + [TestMethod] public void Qbservable_Extensibility_Constructor() { var res1 = Qbservable.Provider.Qux(42).AsObservable().Single(); Assert.Equal(42, res1); } - [Fact] + [TestMethod] public void Qbservable_Extensibility_Missing() { try @@ -1894,7 +1896,7 @@ public void Qbservable_Extensibility_Missing() } #endif - [Fact] + [TestMethod] public void Qbservable_HigherOrder() { var res = Qbservable.Return(Qbservable.Provider, 42).Select(_ => Qbservable.Return(Qbservable.Provider, 42)).Switch().Single(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/AsyncSubjectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/AsyncSubjectTest.cs index 30e68d0458..886a9c205a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/AsyncSubjectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/AsyncSubjectTest.cs @@ -8,26 +8,28 @@ 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 partial class AsyncSubjectTest : ReactiveTest { - [Fact] + [TestMethod] public void Subscribe_ArgumentChecking() { ReactiveAssert.Throws(() => new AsyncSubject().Subscribe(null)); } - [Fact] + [TestMethod] public void OnError_ArgumentChecking() { ReactiveAssert.Throws(() => new AsyncSubject().OnError(null)); } - [Fact] + [TestMethod] public void Infinite() { var scheduler = new TestScheduler(); @@ -84,7 +86,7 @@ public void Infinite() ); } - [Fact] + [TestMethod] public void Finite() { var scheduler = new TestScheduler(); @@ -144,7 +146,7 @@ public void Finite() ); } - [Fact] + [TestMethod] public void Error() { var scheduler = new TestScheduler(); @@ -204,7 +206,7 @@ public void Error() ); } - [Fact] + [TestMethod] public void Canceled() { var scheduler = new TestScheduler(); @@ -255,7 +257,7 @@ public void Canceled() ); } - [Fact] + [TestMethod] public void SubjectDisposed() { var scheduler = new TestScheduler(); @@ -304,14 +306,14 @@ public void SubjectDisposed() #if !NO_THREAD - [Fact] + [TestMethod] public void Await_Blocking() { var s = new AsyncSubject(); GetResult_BlockingImpl(s.GetAwaiter()); } - [Fact] + [TestMethod] public void Await_Throw() { var s = new AsyncSubject(); @@ -319,7 +321,7 @@ public void Await_Throw() } #endif - [Fact] + [TestMethod] public void GetResult_Empty() { var s = new AsyncSubject(); @@ -328,7 +330,7 @@ public void GetResult_Empty() } #if !NO_THREAD - [Fact] + [TestMethod] public void GetResult_Blocking() { GetResult_BlockingImpl(new AsyncSubject()); @@ -358,7 +360,7 @@ private void GetResult_BlockingImpl(AsyncSubject s) Assert.True(s.IsCompleted); } - [Fact] + [TestMethod] public void GetResult_Blocking_Throw() { GetResult_Blocking_ThrowImpl(new AsyncSubject()); @@ -401,7 +403,7 @@ private void GetResult_Blocking_ThrowImpl(AsyncSubject s) } #endif - [Fact] + [TestMethod] public void GetResult_Context() { var x = new AsyncSubject(); @@ -439,7 +441,7 @@ public override void Post(SendOrPostCallback d, object state) } } - [Fact] + [TestMethod] public void HasObservers() { var s = new AsyncSubject(); @@ -464,7 +466,7 @@ public void HasObservers() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_Dispose1() { var s = new AsyncSubject(); @@ -484,7 +486,7 @@ public void HasObservers_Dispose1() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose2() { var s = new AsyncSubject(); @@ -504,7 +506,7 @@ public void HasObservers_Dispose2() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose3() { var s = new AsyncSubject(); @@ -516,7 +518,7 @@ public void HasObservers_Dispose3() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_OnCompleted() { var s = new AsyncSubject(); @@ -532,7 +534,7 @@ public void HasObservers_OnCompleted() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_OnError() { var s = new AsyncSubject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/BehaviorSubjectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/BehaviorSubjectTest.cs index 41d88ec0de..41507a8d48 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/BehaviorSubjectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/BehaviorSubjectTest.cs @@ -6,26 +6,28 @@ using System.Reactive.Concurrency; using System.Reactive.Subjects; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { - + [TestClass] public partial class BehaviorSubjectTest : ReactiveTest { - [Fact] + [TestMethod] public void Subscribe_ArgumentChecking() { ReactiveAssert.Throws(() => new BehaviorSubject(1).Subscribe(null)); } - [Fact] + [TestMethod] public void OnError_ArgumentChecking() { ReactiveAssert.Throws(() => new BehaviorSubject(1).OnError(null)); } - [Fact] + [TestMethod] public void Infinite() { var scheduler = new TestScheduler(); @@ -92,7 +94,7 @@ public void Infinite() ); } - [Fact] + [TestMethod] public void Finite() { var scheduler = new TestScheduler(); @@ -157,7 +159,7 @@ public void Finite() ); } - [Fact] + [TestMethod] public void Error() { var scheduler = new TestScheduler(); @@ -224,7 +226,7 @@ public void Error() ); } - [Fact] + [TestMethod] public void Canceled() { var scheduler = new TestScheduler(); @@ -277,7 +279,7 @@ public void Canceled() ); } - [Fact] + [TestMethod] public void SubjectDisposed() { var scheduler = new TestScheduler(); @@ -335,7 +337,7 @@ public void SubjectDisposed() ); } - [Fact] + [TestMethod] public void HasObservers() { var s = new BehaviorSubject(42); @@ -360,7 +362,7 @@ public void HasObservers() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_Dispose1() { var s = new BehaviorSubject(42); @@ -380,7 +382,7 @@ public void HasObservers_Dispose1() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose2() { var s = new BehaviorSubject(42); @@ -400,7 +402,7 @@ public void HasObservers_Dispose2() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose3() { var s = new BehaviorSubject(42); @@ -412,7 +414,7 @@ public void HasObservers_Dispose3() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_OnCompleted() { var s = new BehaviorSubject(42); @@ -428,7 +430,7 @@ public void HasObservers_OnCompleted() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_OnError() { var s = new BehaviorSubject(42); @@ -444,7 +446,7 @@ public void HasObservers_OnError() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void Value_Initial() { var s = new BehaviorSubject(42); @@ -454,7 +456,7 @@ public void Value_Initial() Assert.Equal(42, x); } - [Fact] + [TestMethod] public void Value_First() { var s = new BehaviorSubject(42); @@ -470,7 +472,7 @@ public void Value_First() Assert.Equal(43, x); } - [Fact] + [TestMethod] public void Value_Second() { var s = new BehaviorSubject(42); @@ -492,7 +494,7 @@ public void Value_Second() Assert.Equal(44, x); } - [Fact] + [TestMethod] public void Value_FrozenAfterOnCompleted() { var s = new BehaviorSubject(42); @@ -526,7 +528,7 @@ public void Value_FrozenAfterOnCompleted() Assert.Equal(44, x); } - [Fact] + [TestMethod] public void Value_ThrowsAfterOnError() { var s = new BehaviorSubject(42); @@ -545,7 +547,7 @@ public void Value_ThrowsAfterOnError() }); } - [Fact] + [TestMethod] public void Value_ThrowsOnDispose() { var s = new BehaviorSubject(42); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/ReplaySubjectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/ReplaySubjectTest.cs index a15e3d882d..66aafc66cf 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/ReplaySubjectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/ReplaySubjectTest.cs @@ -12,14 +12,16 @@ 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 partial class ReplaySubjectTest : ReactiveTest { - [Fact] + [TestMethod] public void Subscribe_ArgumentChecking() { ReactiveAssert.Throws(() => new ReplaySubject().Subscribe(null)); @@ -28,7 +30,7 @@ public void Subscribe_ArgumentChecking() ReactiveAssert.Throws(() => new ReplaySubject(DummyScheduler.Instance).Subscribe(null)); } - [Fact] + [TestMethod] public void OnError_ArgumentChecking() { ReactiveAssert.Throws(() => new ReplaySubject().OnError(null)); @@ -37,7 +39,7 @@ public void OnError_ArgumentChecking() ReactiveAssert.Throws(() => new ReplaySubject(DummyScheduler.Instance).OnError(null)); } - [Fact] + [TestMethod] public void Constructor_ArgumentChecking() { ReactiveAssert.Throws(() => new ReplaySubject(-1)); @@ -64,7 +66,7 @@ public void Constructor_ArgumentChecking() new ReplaySubject(0, TimeSpan.Zero, DummyScheduler.Instance); } - [Fact] + [TestMethod] public void Infinite_ReplayByTime() { var scheduler = new TestScheduler(); @@ -132,7 +134,7 @@ public void Infinite_ReplayByTime() ); } - [Fact] + [TestMethod] public void Infinite_ReplayOne() { var scheduler = new TestScheduler(); @@ -207,7 +209,7 @@ public void Infinite_ReplayOne() ); } - [Fact] + [TestMethod] public void Infinite_ReplayMany() { var scheduler = new TestScheduler(); @@ -279,7 +281,7 @@ public void Infinite_ReplayMany() ); } - [Fact] + [TestMethod] public void Infinite_ReplayAll() { var scheduler = new TestScheduler(); @@ -356,7 +358,7 @@ public void Infinite_ReplayAll() ); } - [Fact] + [TestMethod] public void Infinite2() { var scheduler = new TestScheduler(); @@ -427,7 +429,7 @@ public void Infinite2() ); } - [Fact] + [TestMethod] public void Finite_ReplayByTime() { var scheduler = new TestScheduler(); @@ -492,7 +494,7 @@ public void Finite_ReplayByTime() ); } - [Fact] + [TestMethod] public void Finite_ReplayOne() { var scheduler = new TestScheduler(); @@ -557,7 +559,7 @@ public void Finite_ReplayOne() ); } - [Fact] + [TestMethod] public void Finite_ReplayMany() { var scheduler = new TestScheduler(); @@ -627,7 +629,7 @@ public void Finite_ReplayMany() ); } - [Fact] + [TestMethod] public void Finite_ReplayAll() { var scheduler = new TestScheduler(); @@ -699,7 +701,7 @@ public void Finite_ReplayAll() ); } - [Fact] + [TestMethod] public void Error_ReplayByTime() { var scheduler = new TestScheduler(); @@ -767,7 +769,7 @@ public void Error_ReplayByTime() ); } - [Fact] + [TestMethod] public void Error_ReplayOne() { var scheduler = new TestScheduler(); @@ -834,7 +836,7 @@ public void Error_ReplayOne() ); } - [Fact] + [TestMethod] public void Error_ReplayMany() { var scheduler = new TestScheduler(); @@ -906,7 +908,7 @@ public void Error_ReplayMany() ); } - [Fact] + [TestMethod] public void Error_ReplayAll() { var scheduler = new TestScheduler(); @@ -980,7 +982,7 @@ public void Error_ReplayAll() ); } - [Fact] + [TestMethod] public void Canceled_ReplayByTime() { var scheduler = new TestScheduler(); @@ -1031,7 +1033,7 @@ public void Canceled_ReplayByTime() ); } - [Fact] + [TestMethod] public void Canceled_ReplayOne() { var scheduler = new TestScheduler(); @@ -1082,7 +1084,7 @@ public void Canceled_ReplayOne() ); } - [Fact] + [TestMethod] public void Canceled_ReplayMany() { var scheduler = new TestScheduler(); @@ -1133,7 +1135,7 @@ public void Canceled_ReplayMany() ); } - [Fact] + [TestMethod] public void Canceled_ReplayAll() { var scheduler = new TestScheduler(); @@ -1184,7 +1186,7 @@ public void Canceled_ReplayAll() ); } - [Fact] + [TestMethod] public void SubjectDisposed() { var scheduler = new TestScheduler(); @@ -1245,7 +1247,7 @@ public void SubjectDisposed() ); } - [Fact] + [TestMethod] public void SubjectDisposed_ReplayOne() { var scheduler = new TestScheduler(); @@ -1303,7 +1305,7 @@ public void SubjectDisposed_ReplayOne() ); } - [Fact] + [TestMethod] public void SubjectDisposed_ReplayMany() { var scheduler = new TestScheduler(); @@ -1364,7 +1366,7 @@ public void SubjectDisposed_ReplayMany() ); } - [Fact] + [TestMethod] public void SubjectDisposed_ReplayAll() { var scheduler = new TestScheduler(); @@ -1431,7 +1433,7 @@ public void SubjectDisposed_ReplayAll() // I think it may have to do with calling Trim() on Subscription (as well as in the OnNext calls). -LC // - [Fact] + [TestMethod] public void ReplaySubjectDiesOut() { // @@ -1494,7 +1496,7 @@ public void ReplaySubjectDiesOut() ); } - [Fact] + [TestMethod] public void HasObservers() { HasObserversImpl(new ReplaySubject()); @@ -1526,7 +1528,7 @@ private static void HasObserversImpl(ReplaySubject s) Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_Dispose1() { HasObservers_Dispose1Impl(new ReplaySubject()); @@ -1553,7 +1555,7 @@ private static void HasObservers_Dispose1Impl(ReplaySubject s) Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose2() { HasObservers_Dispose2Impl(new ReplaySubject()); @@ -1580,7 +1582,7 @@ private static void HasObservers_Dispose2Impl(ReplaySubject s) Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose3() { HasObservers_Dispose3Impl(new ReplaySubject()); @@ -1599,7 +1601,7 @@ private static void HasObservers_Dispose3Impl(ReplaySubject s) Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_OnCompleted() { HasObservers_OnCompletedImpl(new ReplaySubject()); @@ -1622,7 +1624,7 @@ private static void HasObservers_OnCompletedImpl(ReplaySubject s) Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_OnError() { HasObservers_OnErrorImpl(new ReplaySubject()); @@ -1645,7 +1647,7 @@ private static void HasObservers_OnErrorImpl(ReplaySubject s) Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void Completed_to_late_subscriber_ReplayAll() { var s = new ReplaySubject(); @@ -1664,7 +1666,7 @@ public void Completed_to_late_subscriber_ReplayAll() Assert.Equal(NotificationKind.OnCompleted, observer.Messages[2].Value.Kind); } - [Fact] + [TestMethod] public void Completed_to_late_subscriber_ReplayOne() { var s = new ReplaySubject(1); @@ -1682,7 +1684,7 @@ public void Completed_to_late_subscriber_ReplayOne() Assert.Equal(NotificationKind.OnCompleted, observer.Messages[1].Value.Kind); } - [Fact] + [TestMethod] public void Completed_to_late_subscriber_ReplayMany() { var s = new ReplaySubject(2); @@ -1702,7 +1704,7 @@ public void Completed_to_late_subscriber_ReplayMany() Assert.Equal(NotificationKind.OnCompleted, observer.Messages[2].Value.Kind); } - [Fact] + [TestMethod] public void Completed_to_late_subscriber_ReplayByTime() { var s = new ReplaySubject(TimeSpan.FromMinutes(1)); @@ -1723,7 +1725,7 @@ public void Completed_to_late_subscriber_ReplayByTime() Assert.Equal(NotificationKind.OnCompleted, observer.Messages[3].Value.Kind); } - [Fact] + [TestMethod] public void Errored_to_late_subscriber_ReplayAll() { var expectedException = new Exception("Test"); @@ -1744,7 +1746,7 @@ public void Errored_to_late_subscriber_ReplayAll() Assert.Equal(expectedException, observer.Messages[2].Value.Exception); } - [Fact] + [TestMethod] public void Errored_to_late_subscriber_ReplayOne() { var expectedException = new Exception("Test"); @@ -1764,7 +1766,7 @@ public void Errored_to_late_subscriber_ReplayOne() Assert.Equal(expectedException, observer.Messages[1].Value.Exception); } - [Fact] + [TestMethod] public void Errored_to_late_subscriber_ReplayMany() { var expectedException = new Exception("Test"); @@ -1786,7 +1788,7 @@ public void Errored_to_late_subscriber_ReplayMany() Assert.Equal(expectedException, observer.Messages[2].Value.Exception); } - [Fact] + [TestMethod] public void Errored_to_late_subscriber_ReplayByTime() { var expectedException = new Exception("Test"); @@ -1809,7 +1811,7 @@ public void Errored_to_late_subscriber_ReplayByTime() Assert.Equal(expectedException, observer.Messages[3].Value.Exception); } - [Fact] + [TestMethod] public void ReplaySubject_Reentrant() { var r = new ReplaySubject(4); @@ -1846,7 +1848,7 @@ public void ReplaySubject_Reentrant() } #if !NO_INTERNALSTEST - [Fact] + [TestMethod] public void FastImmediateObserver_Simple1() { var res = FastImmediateObserverTest(fio => @@ -1867,7 +1869,7 @@ public void FastImmediateObserver_Simple1() ); } - [Fact] + [TestMethod] public void FastImmediateObserver_Simple2() { var ex = new Exception(); @@ -1890,7 +1892,7 @@ public void FastImmediateObserver_Simple2() ); } - [Fact] + [TestMethod] public void FastImmediateObserver_Simple3() { var res = FastImmediateObserverTest(fio => @@ -1916,7 +1918,7 @@ public void FastImmediateObserver_Simple3() ); } - [Fact] + [TestMethod] public void FastImmediateObserver_Fault() { var xs = new List(); @@ -1944,7 +1946,7 @@ public void FastImmediateObserver_Fault() Assert.True(xs.Count == 2); } - [Fact] + [TestMethod] public void FastImmediateObserver_Ownership1() { var xs = new List(); @@ -1980,7 +1982,7 @@ public void FastImmediateObserver_Ownership1() Assert.True(xs.Count == ts.Length * N); } - [Fact] + [TestMethod] public void FastImmediateObserver_Ownership2() { var cd = new CountdownEvent(3); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/SubjectTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/SubjectTest.cs index 0bec68f40e..659267b018 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/SubjectTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/Linq/Subjects/SubjectTest.cs @@ -10,26 +10,28 @@ 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 partial class SubjectTest : ReactiveTest { - [Fact] + [TestMethod] public void Subscribe_ArgumentChecking() { ReactiveAssert.Throws(() => new Subject().Subscribe(null)); } - [Fact] + [TestMethod] public void OnError_ArgumentChecking() { ReactiveAssert.Throws(() => new Subject().OnError(null)); } - [Fact] + [TestMethod] public void Infinite() { var scheduler = new TestScheduler(); @@ -93,7 +95,7 @@ public void Infinite() ); } - [Fact] + [TestMethod] public void Finite() { var scheduler = new TestScheduler(); @@ -156,7 +158,7 @@ public void Finite() ); } - [Fact] + [TestMethod] public void Error() { var scheduler = new TestScheduler(); @@ -221,7 +223,7 @@ public void Error() ); } - [Fact] + [TestMethod] public void Canceled() { var scheduler = new TestScheduler(); @@ -272,7 +274,7 @@ public void Canceled() ); } - [Fact] + [TestMethod] public void Dispose() { var scheduler = new TestScheduler(); @@ -293,7 +295,7 @@ public void Dispose() ); } - [Fact] + [TestMethod] public void PreComplete() { var scheduler = new TestScheduler(); @@ -309,7 +311,7 @@ public void PreComplete() ); } - [Fact] + [TestMethod] public void SubjectDisposed() { var scheduler = new TestScheduler(); @@ -364,7 +366,7 @@ public void SubjectDisposed() ); } - [Fact] + [TestMethod] public void Subject_Create_ArgumentChecking() { ReactiveAssert.Throws(() => Subject.Create(null, Observable.Return(42))); @@ -374,7 +376,7 @@ public void Subject_Create_ArgumentChecking() ReactiveAssert.Throws(() => Subject.Create(Observer.Create(x => { }), null)); } - [Fact] + [TestMethod] public void Subject_Create1() { var _x = default(int); @@ -402,7 +404,7 @@ public void Subject_Create1() Assert.False(done); // already cut off } - [Fact] + [TestMethod] public void Subject_Create2() { var _x = default(int); @@ -430,7 +432,7 @@ public void Subject_Create2() Assert.False(done); // already cut off } - [Fact] + [TestMethod] public void Subject_Synchronize_ArgumentChecking() { var s = new Subject(); @@ -445,7 +447,7 @@ public void Subject_Synchronize_ArgumentChecking() } #if !NO_THREAD - [Fact] + [TestMethod] public void Subject_Synchronize1() { var N = 10; @@ -472,7 +474,7 @@ public void Subject_Synchronize1() Assert.Equal(Enumerable.Range(0, N).Sum(), y); } - [Fact] + [TestMethod] public void Subject_Synchronize2() { var N = 10; @@ -501,7 +503,7 @@ public void Subject_Synchronize2() } #endif - [Fact] + [TestMethod] public void HasObservers() { var s = new Subject(); @@ -526,7 +528,7 @@ public void HasObservers() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_Dispose1() { var s = new Subject(); @@ -546,7 +548,7 @@ public void HasObservers_Dispose1() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose2() { var s = new Subject(); @@ -566,7 +568,7 @@ public void HasObservers_Dispose2() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_Dispose3() { var s = new Subject(); @@ -578,7 +580,7 @@ public void HasObservers_Dispose3() Assert.True(s.IsDisposed); } - [Fact] + [TestMethod] public void HasObservers_OnCompleted() { var s = new Subject(); @@ -594,7 +596,7 @@ public void HasObservers_OnCompleted() Assert.False(s.HasObservers); } - [Fact] + [TestMethod] public void HasObservers_OnError() { var s = new Subject(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ListObservableTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ListObservableTest.cs index a2e6a41ba8..322d5c41b1 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ListObservableTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ListObservableTest.cs @@ -9,61 +9,63 @@ 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 partial class ListObservableTest : ReactiveTest { - [Fact] + [TestMethod] public void Ctor_ArgumentChecking() { ReactiveAssert.Throws(() => new ListObservable(null)); } - [Fact] + [TestMethod] public void Subscribe_ArgumentChecking() { ReactiveAssert.Throws(() => new ListObservable(Observable.Never()).Subscribe(null)); } - [Fact] + [TestMethod] public void Value_None() { var o = new ListObservable(Observable.Empty()); ReactiveAssert.Throws(() => { var t = o.Value; }); } - [Fact] + [TestMethod] public void Value_Some() { var o = new ListObservable(Observable.Range(0, 10)); Assert.Equal(9, o.Value); } - [Fact] + [TestMethod] public void IndexOf_None() { var o = new ListObservable(Observable.Empty()); Assert.Equal(-1, o.IndexOf(0)); } - [Fact] + [TestMethod] public void IndexOf_Some_NotFound() { var o = new ListObservable(Observable.Range(0, 10)); Assert.Equal(-1, o.IndexOf(100)); } - [Fact] + [TestMethod] public void IndexOf_Some_Found() { var o = new ListObservable(Observable.Range(0, 10)); Assert.Equal(3, o.IndexOf(3)); } - [Fact] + [TestMethod] public void RemoveAt_Some_NotFound() { var o = new ListObservable(Observable.Range(0, 10)); @@ -71,7 +73,7 @@ public void RemoveAt_Some_NotFound() o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void RemoveAt_Some_Found() { var o = new ListObservable(Observable.Range(0, 10)); @@ -79,7 +81,7 @@ public void RemoveAt_Some_Found() o.AssertEqual(0, 1, 2, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Insert_Invalid() { var o = new ListObservable(Observable.Range(0, 10)); @@ -87,7 +89,7 @@ public void Insert_Invalid() o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Insert_Invalid_2() { var o = new ListObservable(Observable.Range(0, 10)); @@ -95,7 +97,7 @@ public void Insert_Invalid_2() o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Insert_Beginning() { var o = new ListObservable(Observable.Range(0, 10)); @@ -103,7 +105,7 @@ public void Insert_Beginning() o.AssertEqual(-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Insert_Middle() { var o = new ListObservable(Observable.Range(0, 10)); @@ -111,7 +113,7 @@ public void Insert_Middle() o.AssertEqual(0, 1, 2, -1, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Change_Beginning() { var o = new ListObservable(Observable.Range(0, 10)) @@ -121,7 +123,7 @@ public void Change_Beginning() o.AssertEqual(-1, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Change_Middle() { var o = new ListObservable(Observable.Range(0, 10)) @@ -131,7 +133,7 @@ public void Change_Middle() o.AssertEqual(0, 1, 2, 3, 4, -1, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Change_End() { var o = new ListObservable(Observable.Range(0, 10)) @@ -141,14 +143,14 @@ public void Change_End() o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, -1); } - [Fact] + [TestMethod] public void Change_Error() { var o = new ListObservable(Observable.Range(0, 10)); ReactiveAssert.Throws(() => o[100] = -1); } - [Fact] + [TestMethod] public void Insert_End() { var o = new ListObservable(Observable.Range(0, 10)); @@ -156,28 +158,28 @@ public void Insert_End() o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1); } - [Fact] + [TestMethod] public void Contains_None() { var o = new ListObservable(Observable.Empty()); Assert.Equal(false, o.Contains(0)); } - [Fact] + [TestMethod] public void Contains_Some_NotFound() { var o = new ListObservable(Observable.Range(0, 10)); Assert.Equal(false, o.Contains(100)); } - [Fact] + [TestMethod] public void Contains_Some_Found() { var o = new ListObservable(Observable.Range(0, 10)); Assert.Equal(true, o.Contains(3)); } - [Fact] + [TestMethod] public void Clear() { var o = new ListObservable(Observable.Range(0, 10)); @@ -185,35 +187,35 @@ public void Clear() o.AssertEqual(); } - [Fact] + [TestMethod] public void IsReadOnly() { var o = new ListObservable(Observable.Never()); Assert.Equal(false, o.IsReadOnly); } - [Fact] + [TestMethod] public void This_None() { var o = new ListObservable(Observable.Empty()); ReactiveAssert.Throws(() => { var t = o[0]; }); } - [Fact] + [TestMethod] public void This_Some_NotFound() { var o = new ListObservable(Observable.Range(0, 10)); ReactiveAssert.Throws(() => { var t = o[100]; }); } - [Fact] + [TestMethod] public void This_Some_Found() { var o = new ListObservable(Observable.Range(0, 10)); Assert.Equal(5, o[5]); } - [Fact] + [TestMethod] public void CopyTo_RightSize() { var o = new ListObservable(Observable.Range(0, 10)); @@ -222,7 +224,7 @@ public void CopyTo_RightSize() array.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void CopyTo_RightSize_Offset() { var o = new ListObservable(Observable.Range(0, 10)); @@ -230,7 +232,7 @@ public void CopyTo_RightSize_Offset() ReactiveAssert.Throws(() => o.CopyTo(array, 3)); } - [Fact] + [TestMethod] public void CopyTo_Bigger() { var o = new ListObservable(Observable.Range(0, 10)); @@ -239,7 +241,7 @@ public void CopyTo_Bigger() array.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0); } - [Fact] + [TestMethod] public void CopyTo_Bigger_Offset() { var o = new ListObservable(Observable.Range(0, 10)); @@ -248,7 +250,7 @@ public void CopyTo_Bigger_Offset() array.AssertEqual(0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0); } - [Fact] + [TestMethod] public void CopyTo_Smaller() { var o = new ListObservable(Observable.Range(0, 10)); @@ -256,7 +258,7 @@ public void CopyTo_Smaller() ReactiveAssert.Throws(() => o.CopyTo(array, 0)); } - [Fact] + [TestMethod] public void CopyTo_Smaller_Offset() { var o = new ListObservable(Observable.Range(0, 10)); @@ -264,7 +266,7 @@ public void CopyTo_Smaller_Offset() ReactiveAssert.Throws(() => o.CopyTo(array, 3)); } - [Fact] + [TestMethod] public void Add_Empty() { var o = new ListObservable(Observable.Empty()) @@ -274,7 +276,7 @@ public void Add_Empty() o.AssertEqual(100); } - [Fact] + [TestMethod] public void Add_Some() { var o = new ListObservable(Observable.Return(200)) @@ -284,7 +286,7 @@ public void Add_Some() o.AssertEqual(200, 100); } - [Fact] + [TestMethod] public void Remove_None() { var o = new ListObservable(Observable.Empty()); @@ -292,7 +294,7 @@ public void Remove_None() o.AssertEqual(); } - [Fact] + [TestMethod] public void Remove_Some_NotFound() { var o = new ListObservable(Observable.Range(0, 10)); @@ -300,7 +302,7 @@ public void Remove_Some_NotFound() o.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Remove_Some_Found() { var o = new ListObservable(Observable.Range(0, 10)); @@ -308,7 +310,7 @@ public void Remove_Some_Found() o.AssertEqual(0, 1, 2, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void ForEach() { var o = new ListObservable(Observable.Range(0, 10)); @@ -322,7 +324,7 @@ public void ForEach() l.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void ForEach_Old() { var o = new ListObservable(Observable.Range(0, 10)); @@ -336,7 +338,7 @@ public void ForEach_Old() l.AssertEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); } - [Fact] + [TestMethod] public void Subscribe_Never() { var s = new TestScheduler(); @@ -350,7 +352,7 @@ public void Subscribe_Never() ); } - [Fact] + [TestMethod] public void Subscribe_Infinite() { var s = new TestScheduler(); @@ -365,7 +367,7 @@ public void Subscribe_Infinite() ); } - [Fact] + [TestMethod] public void Subscribe_Error() { var s = new TestScheduler(); @@ -384,7 +386,7 @@ public void Subscribe_Error() ); } - [Fact] + [TestMethod] public void Subscribe_Completed() { var s = new TestScheduler(); @@ -401,7 +403,7 @@ public void Subscribe_Completed() ); } - [Fact] + [TestMethod] public void Subscribe_Disposed() { var s = new TestScheduler(); @@ -417,7 +419,7 @@ public void Subscribe_Disposed() ); } - [Fact] + [TestMethod] public void Subscribe_Disposed_Multi() { var s = new TestScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/NotificationTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/NotificationTest.cs index 022d07a06e..0e7afe2cb4 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/NotificationTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/NotificationTest.cs @@ -6,22 +6,24 @@ using System.Reactive; using System.Threading; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { - + [TestClass] public class NotificationTest : ReactiveTest { #region ToObservable - [Fact] + [TestMethod] public void ToObservable_ArgumentChecking() { ReactiveAssert.Throws(() => Notification.CreateOnNext(1).ToObservable(null)); } - [Fact] + [TestMethod] public void ToObservable_Empty() { var scheduler = new TestScheduler(); @@ -35,7 +37,7 @@ public void ToObservable_Empty() ); } - [Fact] + [TestMethod] public void ToObservable_Return() { var scheduler = new TestScheduler(); @@ -50,7 +52,7 @@ public void ToObservable_Return() ); } - [Fact] + [TestMethod] public void ToObservable_Throw() { var ex = new Exception(); @@ -66,7 +68,7 @@ public void ToObservable_Throw() ); } - [Fact] + [TestMethod] public void ToObservable_CurrentThread() { var evt = new ManualResetEvent(false); @@ -81,7 +83,7 @@ public void ToObservable_CurrentThread() #endregion - [Fact] + [TestMethod] public void Notifications_Equality() { var n = Notification.CreateOnNext(42); @@ -101,7 +103,7 @@ public void Notifications_Equality() Assert.True(c1.Equals(c2)); } - [Fact] + [TestMethod] public void OnNext_CtorAndProps() { var n = Notification.CreateOnNext(42); @@ -111,7 +113,7 @@ public void OnNext_CtorAndProps() Assert.Null(n.Exception); } - [Fact] + [TestMethod] public void OnNext_Equality() { var n1 = Notification.CreateOnNext(42); @@ -141,7 +143,7 @@ public void OnNext_Equality() Assert.False(!(null != n1)); } - [Fact] + [TestMethod] public void OnNext_GetHashCode() { var n1 = Notification.CreateOnNext(42); @@ -151,7 +153,7 @@ public void OnNext_GetHashCode() Assert.Equal(n1.GetHashCode(), n2.GetHashCode()); } - [Fact] + [TestMethod] public void OnNext_ToString() { var n1 = Notification.CreateOnNext(42); @@ -159,7 +161,7 @@ public void OnNext_ToString() Assert.True(n1.ToString().Contains(42.ToString())); } - [Fact] + [TestMethod] public void OnNext_AcceptObserver() { var con = new CheckOnNextObserver(); @@ -189,7 +191,7 @@ public void OnCompleted() } } - [Fact] + [TestMethod] public void OnNext_AcceptObserverWithResult() { var n1 = Notification.CreateOnNext(42); @@ -198,14 +200,14 @@ public void OnNext_AcceptObserverWithResult() Assert.Equal("OK", res); } - [Fact] + [TestMethod] public void OnNext_AcceptObserverWithResult_Null() { var n1 = Notification.CreateOnNext(42); ReactiveAssert.Throws(() => n1.Accept(default(IObserver))); } - [Fact] + [TestMethod] public void OnNext_AcceptAction() { var obs = false; @@ -216,7 +218,7 @@ public void OnNext_AcceptAction() Assert.True(obs); } - [Fact] + [TestMethod] public void OnNext_Accept_ArgumentChecking() { var n = Notification.CreateOnNext(42); @@ -232,7 +234,7 @@ public void OnNext_Accept_ArgumentChecking() ReactiveAssert.Throws(() => n.Accept(x => "", ex => "", default)); } - [Fact] + [TestMethod] public void OnNext_AcceptActionWithResult() { var n1 = Notification.CreateOnNext(42); @@ -241,13 +243,13 @@ public void OnNext_AcceptActionWithResult() Assert.Equal("OK", res); } - [Fact] + [TestMethod] public void OnError_CtorNull() { ReactiveAssert.Throws(() => Notification.CreateOnError(null)); } - [Fact] + [TestMethod] public void OnError_Accept_ArgumentChecking() { var n = Notification.CreateOnError(new Exception()); @@ -263,7 +265,7 @@ public void OnError_Accept_ArgumentChecking() ReactiveAssert.Throws(() => n.Accept(x => "", ex => "", default)); } - [Fact] + [TestMethod] public void OnError_CtorAndProps() { var e = new Exception(); @@ -283,7 +285,7 @@ public void OnError_CtorAndProps() } } - [Fact] + [TestMethod] public void OnError_Equality() { var ex1 = new Exception(); @@ -316,7 +318,7 @@ public void OnError_Equality() Assert.False(!(null != n1)); } - [Fact] + [TestMethod] public void OnError_GetHashCode() { var ex = new Exception(); @@ -328,7 +330,7 @@ public void OnError_GetHashCode() Assert.Equal(n1.GetHashCode(), n2.GetHashCode()); } - [Fact] + [TestMethod] public void OnError_ToString() { var ex = new Exception(); @@ -338,7 +340,7 @@ public void OnError_ToString() Assert.True(n1.ToString().Contains(ex.GetType().Name)); // CHECK, no message? } - [Fact] + [TestMethod] public void OnError_AcceptObserver() { var ex = new Exception(); @@ -371,7 +373,7 @@ public void OnCompleted() } } - [Fact] + [TestMethod] public void OnError_AcceptObserverWithResult() { var ex = new Exception(); @@ -382,14 +384,14 @@ public void OnError_AcceptObserverWithResult() Assert.Equal("OK", res); } - [Fact] + [TestMethod] public void OnError_AcceptObserverWithResult_Null() { var n1 = Notification.CreateOnError(new Exception()); ReactiveAssert.Throws(() => n1.Accept(default(IObserver))); } - [Fact] + [TestMethod] public void OnError_AcceptAction() { var ex = new Exception(); @@ -402,7 +404,7 @@ public void OnError_AcceptAction() Assert.True(obs); } - [Fact] + [TestMethod] public void OnError_AcceptActionWithResult() { var ex = new Exception(); @@ -413,7 +415,7 @@ public void OnError_AcceptActionWithResult() Assert.Equal("OK", res); } - [Fact] + [TestMethod] public void OnCompleted_CtorAndProps() { var n = Notification.CreateOnCompleted(); @@ -435,7 +437,7 @@ public void OnCompleted_CtorAndProps() Assert.True(ok); } - [Fact] + [TestMethod] public void OnCompleted_Accept_ArgumentChecking() { var n = Notification.CreateOnCompleted(); @@ -451,7 +453,7 @@ public void OnCompleted_Accept_ArgumentChecking() ReactiveAssert.Throws(() => n.Accept(x => "", ex => "", default)); } - [Fact] + [TestMethod] public void OnCompleted_Equality() { var n1 = Notification.CreateOnCompleted(); @@ -478,7 +480,7 @@ public void OnCompleted_Equality() Assert.False(!(null != n1)); } - [Fact] + [TestMethod] public void OnCompleted_GetHashCode() { var n1 = Notification.CreateOnCompleted(); @@ -488,14 +490,14 @@ public void OnCompleted_GetHashCode() Assert.Equal(n1.GetHashCode(), n2.GetHashCode()); } - [Fact] + [TestMethod] public void OnCompleted_ToString() { var n1 = Notification.CreateOnCompleted(); Assert.True(n1.ToString().Contains("OnCompleted")); } - [Fact] + [TestMethod] public void OnCompleted_AcceptObserver() { var obs = new CheckOnCompletedObserver(); @@ -526,7 +528,7 @@ public void OnCompleted() } } - [Fact] + [TestMethod] public void OnCompleted_AcceptObserverWithResult() { var n1 = Notification.CreateOnCompleted(); @@ -535,14 +537,14 @@ public void OnCompleted_AcceptObserverWithResult() Assert.Equal("OK", res); } - [Fact] + [TestMethod] public void OnCompleted_AcceptObserverWithResult_Null() { var n1 = Notification.CreateOnCompleted(); ReactiveAssert.Throws(() => n1.Accept(default(IObserver))); } - [Fact] + [TestMethod] public void OnCompleted_AcceptAction() { var obs = false; @@ -553,7 +555,7 @@ public void OnCompleted_AcceptAction() Assert.True(obs); } - [Fact] + [TestMethod] public void OnCompleted_AcceptActionWithResult() { var n1 = Notification.CreateOnCompleted(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ObserverTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ObserverTest.cs index c53882eb54..bbdfe54a01 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ObserverTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/ObserverTest.cs @@ -10,20 +10,22 @@ 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 partial class ObserverTest : ReactiveTest { - [Fact] + [TestMethod] public void ToObserver_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.ToObserver(default(Action>))); } - [Fact] + [TestMethod] public void ToObserver_NotificationOnNext() { var i = 0; @@ -38,7 +40,7 @@ public void ToObserver_NotificationOnNext() next.ToObserver().OnNext(42); } - [Fact] + [TestMethod] public void ToObserver_NotificationOnError() { var ex = new Exception(); @@ -53,7 +55,7 @@ public void ToObserver_NotificationOnError() next.ToObserver().OnError(ex); } - [Fact] + [TestMethod] public void ToObserver_NotificationOnCompleted() { var ex = new Exception(); @@ -67,13 +69,13 @@ public void ToObserver_NotificationOnCompleted() next.ToObserver().OnCompleted(); } - [Fact] + [TestMethod] public void ToNotifier_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.ToNotifier(default)); } - [Fact] + [TestMethod] public void ToNotifier_Forwards() { var obsn = new MyObserver(); @@ -90,7 +92,7 @@ public void ToNotifier_Forwards() Assert.True(obsc.HasOnCompleted); } - [Fact] + [TestMethod] public void Create_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.Create(default)); @@ -103,7 +105,7 @@ public void Create_ArgumentChecking() ReactiveAssert.Throws(() => Observer.Create(_ => { }, (Exception _) => { }, default)); } - [Fact] + [TestMethod] public void Create_OnNext() { var next = false; @@ -113,7 +115,7 @@ public void Create_OnNext() res.OnCompleted(); } - [Fact] + [TestMethod] public void Create_OnNext_HasError() { var ex = new Exception(); @@ -136,7 +138,7 @@ public void Create_OnNext_HasError() Assert.Same(ex, e_); } - [Fact] + [TestMethod] public void Create_OnNextOnCompleted() { var next = false; @@ -149,7 +151,7 @@ public void Create_OnNextOnCompleted() Assert.True(completed); } - [Fact] + [TestMethod] public void Create_OnNextOnCompleted_HasError() { var ex = new Exception(); @@ -174,7 +176,7 @@ public void Create_OnNextOnCompleted_HasError() Assert.False(completed); } - [Fact] + [TestMethod] public void Create_OnNextOnError() { var ex = new Exception(); @@ -188,7 +190,7 @@ public void Create_OnNextOnError() Assert.True(error); } - [Fact] + [TestMethod] public void Create_OnNextOnError_HitCompleted() { var ex = new Exception(); @@ -202,7 +204,7 @@ public void Create_OnNextOnError_HitCompleted() Assert.False(error); } - [Fact] + [TestMethod] public void Create_OnNextOnErrorOnCompleted1() { var ex = new Exception(); @@ -219,7 +221,7 @@ public void Create_OnNextOnErrorOnCompleted1() Assert.False(error); } - [Fact] + [TestMethod] public void Create_OnNextOnErrorOnCompleted2() { var ex = new Exception(); @@ -236,13 +238,13 @@ public void Create_OnNextOnErrorOnCompleted2() Assert.False(completed); } - [Fact] + [TestMethod] public void AsObserver_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.AsObserver(default)); } - [Fact] + [TestMethod] public void AsObserver_Hides() { var obs = new MyObserver(); @@ -251,7 +253,7 @@ public void AsObserver_Hides() Assert.False(ReferenceEquals(obs, res)); } - [Fact] + [TestMethod] public void AsObserver_Forwards() { var obsn = new MyObserver(); @@ -290,13 +292,13 @@ public void OnCompleted() public bool HasOnCompleted { get; set; } } - [Fact] + [TestMethod] public void Observer_Checked_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.Checked(default(IObserver))); } - [Fact] + [TestMethod] public void Observer_Checked_AlreadyTerminated_Completed() { var m = 0; @@ -315,7 +317,7 @@ public void Observer_Checked_AlreadyTerminated_Completed() Assert.Equal(1, n); } - [Fact] + [TestMethod] public void Observer_Checked_AlreadyTerminated_Error() { var m = 0; @@ -334,7 +336,7 @@ public void Observer_Checked_AlreadyTerminated_Error() Assert.Equal(1, n); } - [Fact] + [TestMethod] public void Observer_Checked_Reentrant_Next() { var n = 0; @@ -364,7 +366,7 @@ public void Observer_Checked_Reentrant_Next() Assert.Equal(1, n); } - [Fact] + [TestMethod] public void Observer_Checked_Reentrant_Error() { var n = 0; @@ -394,7 +396,7 @@ public void Observer_Checked_Reentrant_Error() Assert.Equal(1, n); } - [Fact] + [TestMethod] public void Observer_Checked_Reentrant_Completed() { var n = 0; @@ -424,7 +426,7 @@ public void Observer_Checked_Reentrant_Completed() Assert.Equal(1, n); } - [Fact] + [TestMethod] public void Observer_Synchronize_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.Synchronize(default(IObserver))); @@ -438,7 +440,7 @@ public void Observer_Synchronize_ArgumentChecking() ReactiveAssert.Throws(() => Observer.Synchronize(new MyObserver(), default(AsyncLock))); } - [Fact] + [TestMethod] public void Observer_Synchronize_Monitor_Reentrant1() { var res = false; @@ -467,7 +469,7 @@ public void Observer_Synchronize_Monitor_Reentrant1() Assert.True(res); } - [Fact] + [TestMethod] public void Observer_Synchronize_Monitor_Reentrant2() { var res = false; @@ -496,7 +498,7 @@ public void Observer_Synchronize_Monitor_Reentrant2() Assert.True(res); } - [Fact] + [TestMethod] public void Observer_Synchronize_Monitor_Reentrant3() { var res = false; @@ -525,7 +527,7 @@ public void Observer_Synchronize_Monitor_Reentrant3() Assert.True(res); } - [Fact] + [TestMethod] public void Observer_Synchronize_AsyncLock_NonReentrant1() { var res = false; @@ -554,7 +556,7 @@ public void Observer_Synchronize_AsyncLock_NonReentrant1() Assert.True(res); } - [Fact] + [TestMethod] public void Observer_Synchronize_AsyncLock_NonReentrant2() { var res = false; @@ -583,7 +585,7 @@ public void Observer_Synchronize_AsyncLock_NonReentrant2() Assert.True(res); } - [Fact] + [TestMethod] public void Observer_Synchronize_AsyncLock() { { @@ -643,13 +645,13 @@ public void Observer_Synchronize_AsyncLock() } } - [Fact] + [TestMethod] public void Observer_Synchronize_OnCompleted() { Observer_Synchronize(true); } - [Fact] + [TestMethod] public void Observer_Synchronize_OnError() { Observer_Synchronize(false); @@ -723,7 +725,7 @@ private void Observer_Synchronize(bool success) Assert.Equal(n, N * M); } - [Fact] + [TestMethod] public void NotifyOn_Null() { ReactiveAssert.Throws(() => Observer.NotifyOn(default(IObserver), Scheduler.Immediate)); @@ -733,13 +735,13 @@ public void NotifyOn_Null() } #if !NO_THREAD - [Fact] + [TestMethod] public void NotifyOn_Scheduler_OnCompleted() { NotifyOn_Scheduler(true); } - [Fact] + [TestMethod] public void NotifyOn_Scheduler_OnError() { NotifyOn_Scheduler(false); @@ -799,7 +801,7 @@ private void NotifyOn_Scheduler(bool success) } #endif - [Fact] + [TestMethod] public void NotifyOn_SyncCtx() { var lst = new List(); @@ -827,7 +829,7 @@ public override void Post(SendOrPostCallback d, object state) } } - [Fact] + [TestMethod] public void Observer_ToProgress_ArgumentChecking() { var s = Scheduler.Immediate; @@ -839,7 +841,7 @@ public void Observer_ToProgress_ArgumentChecking() ReactiveAssert.Throws(() => Observer.ToProgress(o, default)); } - [Fact] + [TestMethod] public void Observer_ToProgress() { var xs = new List(); @@ -852,7 +854,7 @@ public void Observer_ToProgress() Assert.True(xs.SequenceEqual(new[] { 42, 43 })); } - [Fact] + [TestMethod] public void Observer_ToProgress_Scheduler() { var s = new TestScheduler(); @@ -874,13 +876,13 @@ public void Observer_ToProgress_Scheduler() ); } - [Fact] + [TestMethod] public void Progress_ToObserver_ArgumentChecking() { ReactiveAssert.Throws(() => Observer.ToObserver(default(IProgress))); } - [Fact] + [TestMethod] public void Progress_ToObserver() { var xs = new List(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/PrivateTypesTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/PrivateTypesTest.cs index 3d41d519c4..85b363e142 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/PrivateTypesTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/PrivateTypesTest.cs @@ -7,14 +7,16 @@ using System.Reactive.Linq; using System.Reflection; using Microsoft.Reactive.Testing; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { - + [TestClass] public partial class PrivateTypesTest : ReactiveTest { - [Fact] + [TestMethod] public void EitherValueRoundtrip() { { @@ -29,7 +31,7 @@ public void EitherValueRoundtrip() } } - [Fact] + [TestMethod] public void EitherEqualsEquatable() { { @@ -54,7 +56,7 @@ public void EitherEqualsEquatable() } } - [Fact] + [TestMethod] public void EitherEqualsObject() { { @@ -79,7 +81,7 @@ public void EitherEqualsObject() } } - [Fact] + [TestMethod] public void EitherGetHashCode() { { @@ -94,7 +96,7 @@ public void EitherGetHashCode() } } - [Fact] + [TestMethod] public void EitherToString() { { @@ -107,7 +109,7 @@ public void EitherToString() } } - [Fact] + [TestMethod] public void EitherSwitchFunc() { { @@ -122,7 +124,7 @@ public void EitherSwitchFunc() } } - [Fact] + [TestMethod] public void EitherSwitchAction() { { diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/RegressionTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/RegressionTest.cs index 5859fb8e77..f11c773a77 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/RegressionTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/RegressionTest.cs @@ -11,14 +11,16 @@ 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 RegressionTest : ReactiveTest { - [Fact] + [TestMethod] public void Bug_ConcurrentMerge() { const int reps = 1000; @@ -42,7 +44,7 @@ public void Bug_ConcurrentMerge() Assert.True(Enumerable.Range(0, reps).ToList().SequenceEqual(resultQueue.ToList())); } - [Fact] + [TestMethod] public void Bug_1283() { var scheduler = new TestScheduler(); @@ -71,7 +73,7 @@ public void Bug_1283() ); } - [Fact] + [TestMethod] public void Bug_1261() { var scheduler = new TestScheduler(); @@ -103,7 +105,7 @@ public void Bug_1261() ); } - [Fact] + [TestMethod] public void Bug_1130() { var xs = Observable.Start(() => 5); @@ -111,7 +113,7 @@ public void Bug_1130() } #if !NO_THREAD - [Fact] + [TestMethod] public void Bug_1286() { var infinite = Observable.Return(new { Name = "test", Value = 0d }, DefaultScheduler.Instance).Repeat(); @@ -127,7 +129,7 @@ public void Bug_1286() } #endif - [Fact] + [TestMethod] public void Bug_1287() { var flag = false; @@ -146,7 +148,7 @@ private static IEnumerable Bug_1333_Enumerable(AsyncSubject s, yield return 1; } - [Fact] + [TestMethod] //[Timeout(1000)] public void Bug_1333() { @@ -159,7 +161,7 @@ public void Bug_1333() } #endif - [Fact] + [TestMethod] public void Bug_1295_Completed() { var scheduler = new TestScheduler(); @@ -186,7 +188,7 @@ public void Bug_1295_Completed() ); } - [Fact] + [TestMethod] public void Bug_1295_Error() { var scheduler = new TestScheduler(); @@ -214,7 +216,7 @@ public void Bug_1295_Error() ); } - [Fact] + [TestMethod] public void Bug_1297_Catch_None() { var scheduler = new TestScheduler(); @@ -228,7 +230,7 @@ public void Bug_1297_Catch_None() ); } - [Fact] + [TestMethod] public void Bug_1297_OnErrorResumeNext_None() { var scheduler = new TestScheduler(); @@ -242,7 +244,7 @@ public void Bug_1297_OnErrorResumeNext_None() ); } - [Fact] + [TestMethod] public void Bug_1297_Catch_Single() { var scheduler = new TestScheduler(); @@ -260,7 +262,7 @@ public void Bug_1297_Catch_Single() ); } - [Fact] + [TestMethod] public void Bug_1297_OnErrorResumeNext_Single() { var scheduler = new TestScheduler(); @@ -276,7 +278,7 @@ public void Bug_1297_OnErrorResumeNext_Single() ); } - [Fact] + [TestMethod] public void Bug_1297_Catch_Multi() { var scheduler = new TestScheduler(); @@ -298,7 +300,7 @@ public void Bug_1297_Catch_Multi() ); } - [Fact] + [TestMethod] public void Bug_1297_OnErrorResumeNext_Multi() { var scheduler = new TestScheduler(); @@ -320,7 +322,7 @@ public void Bug_1297_OnErrorResumeNext_Multi() ); } - [Fact] + [TestMethod] public void Bug_1380() { var scheduler = new TestScheduler(); @@ -355,7 +357,7 @@ public void Bug_1380() } - [Fact] + [TestMethod] public void Bug_1356() { var run = false; @@ -363,7 +365,7 @@ public void Bug_1356() Assert.True(run); } - [Fact] + [TestMethod] public void Bug_1381() { var scheduler = new TestScheduler(); @@ -409,7 +411,7 @@ public void Bug_1381() ); } - [Fact] + [TestMethod] public void Reentrant_Subject1() { var s = Subject.Synchronize((ISubject)new Subject(), Scheduler.Immediate); @@ -432,7 +434,7 @@ public void Reentrant_Subject1() list.AssertEqual(1, -1, 2, -2, 3, -3); } - [Fact] + [TestMethod] public void Reentrant_Subject2() { var s = Subject.Synchronize(new Subject(), Scheduler.Immediate); @@ -455,7 +457,7 @@ public void Reentrant_Subject2() list.AssertEqual(1, -1, 2, -2, 3, -3); } - [Fact] + [TestMethod] public void Merge_Trampoline1() { var ys = new[] { 1, 2, 3 }.ToObservable().Publish(xs => xs.Merge(xs)); @@ -466,7 +468,7 @@ public void Merge_Trampoline1() list.AssertEqual(1, 1, 2, 2, 3, 3); } - [Fact] + [TestMethod] public void Merge_Trampoline2() { var ys = new[] { 1, 2, 3 }.ToObservable().Publish(xs => Observable.Merge(xs, xs, xs, xs)); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/SystemClockTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/SystemClockTest.cs index 94e5bec787..1b6313a8c5 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/SystemClockTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/SystemClockTest.cs @@ -9,7 +9,9 @@ using System.Reactive.Concurrency; using System.Reactive.Disposables; using System.Reactive.PlatformServices; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { @@ -23,7 +25,7 @@ public static T Deq(this List l) } } - + [TestClass] public class SystemClockTest { private void Run(CrossAppDomainDelegate a) @@ -33,7 +35,7 @@ private void Run(CrossAppDomainDelegate a) AppDomain.Unload(domain); } - [Fact] + [TestMethod] public void PastWork() { Run(PastWork_Callback); @@ -65,7 +67,7 @@ private static void PastWork_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void ImmediateWork() { Run(ImmediateWork_Callback); @@ -97,7 +99,7 @@ private static void ImmediateWork_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void ShortTermWork() { Run(ShortTermWork_Callback); @@ -130,7 +132,7 @@ private static void ShortTermWork_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void ShortTermWork_Dispose() { Run(ShortTermWork_Dispose_Callback); @@ -165,7 +167,7 @@ private static void ShortTermWork_Dispose_Callback() Assert.False(done); } - [Fact] + [TestMethod] public void ShortTermWork_InaccurateClock() { Run(ShortTermWork_InaccurateClock_Callback); @@ -206,7 +208,7 @@ private static void ShortTermWork_InaccurateClock_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void LongTermWork1() { Run(LongTermWork1_Callback); @@ -247,7 +249,7 @@ private static void LongTermWork1_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void LongTermWork2() { Run(LongTermWork2_Callback); @@ -298,7 +300,7 @@ private static void LongTermWork2_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void LongTerm_Multiple() { Run(LongTerm_Multiple_Callback); @@ -385,7 +387,7 @@ private static void LongTerm_Multiple_Callback() Assert.True(done3); } - [Fact] + [TestMethod] public void LongTerm_Multiple_Dispose() { Run(LongTerm_Multiple_Dispose_Callback); @@ -480,7 +482,7 @@ private static void LongTerm_Multiple_Dispose_Callback() Assert.False(done3); } - [Fact] + [TestMethod] public void ClockChanged_FalsePositive() { Run(ClockChanged_FalsePositive_Callback); @@ -526,7 +528,7 @@ private static void ClockChanged_FalsePositive_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void ClockChanged_Forward1() { Run(ClockChanged_Forward1_Callback); @@ -571,7 +573,7 @@ private static void ClockChanged_Forward1_Callback() Assert.Equal(0, s._queue.Count); } - [Fact] + [TestMethod] public void ClockChanged_Forward2() { Run(ClockChanged_Forward2_Callback); @@ -615,7 +617,7 @@ private static void ClockChanged_Forward2_Callback() Assert.Equal(1, n); // Invoke shouldn't cause double execution of the work. } - [Fact] + [TestMethod] public void ClockChanged_Backward1() { Run(ClockChanged_Backward1_Callback); @@ -668,7 +670,7 @@ private static void ClockChanged_Backward1_Callback() Assert.True(done); } - [Fact] + [TestMethod] public void ClockChanged_Backward2() { Run(ClockChanged_Backward2_Callback); @@ -724,7 +726,7 @@ private static void ClockChanged_Backward2_Callback() Assert.Equal(1, n); // Invoke shouldn't cause double execution of the work. } - [Fact] + [TestMethod] public void PeriodicSystemClockChangeMonitor() { Run(PeriodicSystemClockChangeMonitor_Callback); @@ -794,7 +796,7 @@ private static void PeriodicSystemClockChangeMonitor_Callback() Assert.Null(cal._action); } - [Fact] + [TestMethod] public void ClockChanged_RefCounting() { Run(ClockChanged_RefCounting_Callback); @@ -905,7 +907,7 @@ private static void ClockChanged_RefCounting_Callback() Assert.Equal(0, scm.N); } - [Fact] + [TestMethod] public void SystemClockChange_SignalNoInvalidOperationExceptionDueToRemove() { var local = new RemoveScheduler(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskLikeSupportTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskLikeSupportTest.cs index 3b87e7837c..e98f9e3e61 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskLikeSupportTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskLikeSupportTest.cs @@ -5,14 +5,18 @@ using System; using System.Reactive; using System.Reactive.Linq; +using System.Threading; using System.Threading.Tasks; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace Tests.System.Reactive.Tests { + [TestClass] public class TaskLikeSupportTest { - [Fact] + [TestMethod] public async Task Return() { Assert.Equal(42, await ManOrBoy_Return()); @@ -25,7 +29,7 @@ private async ITaskObservable ManOrBoy_Return() } #pragma warning restore 1998 - [Fact] + [TestMethod] public async Task Throw() { await Assert.ThrowsAsync(async () => await ManOrBoy_Throw(42, 0)); @@ -38,12 +42,55 @@ private async ITaskObservable ManOrBoy_Throw(int n, int d) } #pragma warning restore 1998 - [Fact] - public async Task Basics() + // We execute the ManOrBoy_Basics tests twice, once without a SynchronizationContext, and + // once with one. When we were on xUnit, SynchronizationContext.Current was never null + // because xUnit populates it with their AsyncTestSyncContext, apparently to ensure that + // async void tests work. MSTest takes the more strict view that async void tests should + // not be encouraged. (It has an analyzer to detect these and warn you about them). So + // tests in MSTest get the default behaviour (i.e. SynchronizationContext.Current will be + // null) unless the test sets one up explicitly. + // + // The ManOrBoy_Basics tests exercise different code paths depending on the availability of + // a SynchronizationContext. AsyncSubject.AwaitObserver.InvokeOnOriginalContext will go + // via the context if there is one, and invokes its callback synchronously if not. This is + // a significant difference, which is why, now that we can test both ways, we do. + // + // When we switched to MSTest, and before we had added the tests to run both with and + // without the SynchronizationContext (meaning we only tested without one) this test + // started failing intermittently. This seems likely to be indicative of a subtle bug in + // Rx, because there doesn't seem to be any obvious reason why this should be expected to + // deadlock in the absence of a synchronization context. It doesn't fail if you run the + // test in isolation. It only happens when running all the tests, and even then it often + // doesn't. Since we modified the build to apply a default timeout to all tests with the + // aim of trying to work out which tests were occasionally locking up, the failures have + // not yet recurred, suggesting that there's some sort of race condition here that's finely + // balanced enough to be affected by test settings. Maybe there's some subtle reason why + // you should never attempt to do what this test is doing without a + // SynchronizationContext, but if so, it's unclear what that might be. + // Issue https://github.com/dotnet/reactive/issues/1885 is tracking this until we + // resolve the root cause of the occasional failures. + + [TestMethod] + public async Task BasicsNoSynchronizationContext() { Assert.Equal(45, await ManOrBoy_Basics()); } + [TestMethod] + public async Task BasicsWithSynchronizationContext() + { + SynchronizationContext ctx = SynchronizationContext.Current; + try + { + SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); + Assert.Equal(45, await ManOrBoy_Basics()); + } + finally + { + SynchronizationContext.SetSynchronizationContext(ctx); + } + } + #pragma warning disable 1998 private async ITaskObservable ManOrBoy_Basics() { diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskObservableExtensionsTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskObservableExtensionsTest.cs index d07a91f80b..2172cff19a 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskObservableExtensionsTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TaskObservableExtensionsTest.cs @@ -11,11 +11,13 @@ 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 TaskObservableExtensionsTest : ReactiveTest { private readonly Task _doneTask; @@ -29,7 +31,7 @@ public TaskObservableExtensionsTest() #region ToObservable - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_ArgumentChecking() { var s = Scheduler.Immediate; @@ -44,7 +46,7 @@ public void TaskToObservable_NonVoid_ArgumentChecking() ReactiveAssert.Throws(() => task.ToObservable().Subscribe(null)); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Complete_BeforeCreate() { var taskScheduler = new TestTaskScheduler(); @@ -71,7 +73,7 @@ public void TaskToObservable_NonVoid_Complete_BeforeCreate() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Complete_BeforeSubscribe() { var taskScheduler = new TestTaskScheduler(); @@ -98,7 +100,7 @@ public void TaskToObservable_NonVoid_Complete_BeforeSubscribe() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Complete_BeforeDispose() { var taskScheduler = new TestTaskScheduler(); @@ -125,7 +127,7 @@ public void TaskToObservable_NonVoid_Complete_BeforeDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Complete_AfterDispose() { var taskScheduler = new TestTaskScheduler(); @@ -150,7 +152,7 @@ public void TaskToObservable_NonVoid_Complete_AfterDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Exception_BeforeCreate() { var taskScheduler = new TestTaskScheduler(); @@ -178,7 +180,7 @@ public void TaskToObservable_NonVoid_Exception_BeforeCreate() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Exception_BeforeSubscribe() { var taskScheduler = new TestTaskScheduler(); @@ -206,7 +208,7 @@ public void TaskToObservable_NonVoid_Exception_BeforeSubscribe() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Exception_BeforeDispose() { var taskScheduler = new TestTaskScheduler(); @@ -234,7 +236,7 @@ public void TaskToObservable_NonVoid_Exception_BeforeDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Exception_AfterDispose() { var taskScheduler = new TestTaskScheduler(); @@ -259,7 +261,7 @@ public void TaskToObservable_NonVoid_Exception_AfterDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Canceled_BeforeCreate() { var taskScheduler = new TestTaskScheduler(); @@ -285,7 +287,7 @@ public void TaskToObservable_NonVoid_Canceled_BeforeCreate() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Canceled_BeforeSubscribe() { var taskScheduler = new TestTaskScheduler(); @@ -311,7 +313,7 @@ public void TaskToObservable_NonVoid_Canceled_BeforeSubscribe() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Canceled_BeforeDispose() { var taskScheduler = new TestTaskScheduler(); @@ -337,7 +339,7 @@ public void TaskToObservable_NonVoid_Canceled_BeforeDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Canceled_AfterDispose() { var taskScheduler = new TestTaskScheduler(); @@ -363,7 +365,7 @@ public void TaskToObservable_NonVoid_Canceled_AfterDispose() } #if DESKTOPCLR - [Fact] + [TestMethod] public void TaskToObservable_NonVoid_Scheduler() { var e = new ManualResetEvent(false); @@ -389,7 +391,7 @@ public void TaskToObservable_NonVoid_Scheduler() } #endif - [Fact] + [TestMethod] public void TaskToObservable_Void_ArgumentChecking() { var s = Scheduler.Immediate; @@ -404,7 +406,7 @@ public void TaskToObservable_Void_ArgumentChecking() ReactiveAssert.Throws(() => task.ToObservable().Subscribe(null)); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Complete_BeforeCreate() { var taskScheduler = new TestTaskScheduler(); @@ -431,7 +433,7 @@ public void TaskToObservable_Void_Complete_BeforeCreate() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Complete_BeforeSubscribe() { var taskScheduler = new TestTaskScheduler(); @@ -458,7 +460,7 @@ public void TaskToObservable_Void_Complete_BeforeSubscribe() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Complete_BeforeDispose() { var taskScheduler = new TestTaskScheduler(); @@ -485,7 +487,7 @@ public void TaskToObservable_Void_Complete_BeforeDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Complete_AfterDispose() { var taskScheduler = new TestTaskScheduler(); @@ -510,7 +512,7 @@ public void TaskToObservable_Void_Complete_AfterDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Exception_BeforeCreate() { var taskScheduler = new TestTaskScheduler(); @@ -538,7 +540,7 @@ public void TaskToObservable_Void_Exception_BeforeCreate() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Exception_BeforeSubscribe() { var taskScheduler = new TestTaskScheduler(); @@ -566,7 +568,7 @@ public void TaskToObservable_Void_Exception_BeforeSubscribe() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Exception_BeforeDispose() { var taskScheduler = new TestTaskScheduler(); @@ -594,7 +596,7 @@ public void TaskToObservable_Void_Exception_BeforeDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Exception_AfterDispose() { var taskScheduler = new TestTaskScheduler(); @@ -619,7 +621,7 @@ public void TaskToObservable_Void_Exception_AfterDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Canceled_BeforeCreate() { var taskScheduler = new TestTaskScheduler(); @@ -645,7 +647,7 @@ public void TaskToObservable_Void_Canceled_BeforeCreate() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Canceled_BeforeSubscribe() { var taskScheduler = new TestTaskScheduler(); @@ -671,7 +673,7 @@ public void TaskToObservable_Void_Canceled_BeforeSubscribe() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Canceled_BeforeDispose() { var taskScheduler = new TestTaskScheduler(); @@ -697,7 +699,7 @@ public void TaskToObservable_Void_Canceled_BeforeDispose() ); } - [Fact] + [TestMethod] public void TaskToObservable_Void_Canceled_AfterDispose() { var taskScheduler = new TestTaskScheduler(); @@ -723,7 +725,7 @@ public void TaskToObservable_Void_Canceled_AfterDispose() } #if DESKTOPCLR - [Fact] + [TestMethod] public void TaskToObservable_Void_Scheduler() { var e = new ManualResetEvent(false); @@ -750,7 +752,7 @@ public void TaskToObservable_Void_Scheduler() #region ToTask - [Fact] + [TestMethod] public void ObservableToTask_ArgumentChecking() { ReactiveAssert.Throws(() => TaskObservableExtensions.ToTask(null)); @@ -764,7 +766,7 @@ public void ObservableToTask_ArgumentChecking() ReactiveAssert.Throws(() => TaskObservableExtensions.ToTask(Observable.Never(), new CancellationToken(), new object(), scheduler: null)); } - [Fact] + [TestMethod] public void ObservableToTaskNoValue() { var scheduler = new TestScheduler(); @@ -780,7 +782,7 @@ public void ObservableToTaskNoValue() Assert.Equal(1, scheduler.Clock); } - [Fact] + [TestMethod] public void ObservableToTaskSingleValue() { var scheduler = new TestScheduler(); @@ -796,7 +798,7 @@ public void ObservableToTaskSingleValue() Assert.Equal(1, scheduler.Clock); } - [Fact] + [TestMethod] public void ObservableToTaskMultipleValues() { var scheduler = new TestScheduler(); @@ -819,7 +821,7 @@ public void ObservableToTaskMultipleValues() ); } - [Fact] + [TestMethod] public void ObservableToTaskException() { var scheduler = new TestScheduler(); @@ -846,7 +848,7 @@ public void ObservableToTaskException() ); } - [Fact] + [TestMethod] public void ObservableToTaskCancelled() { var scheduler = new TestScheduler(); @@ -870,7 +872,7 @@ public void ObservableToTaskCancelled() ); } - [Fact] + [TestMethod] public void ObservableToTaskWithStateSingleValue() { var state = "bar"; @@ -890,7 +892,7 @@ public void ObservableToTaskWithStateSingleValue() Assert.Equal(1, scheduler.Clock); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Success() { var scheduler = new OneshotScheduler(); @@ -906,7 +908,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Success() Assert.True(task.IsCompleted); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Failure() { var scheduler = new OneshotScheduler(); @@ -924,7 +926,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Failure() Assert.Equal("failure", task.Exception.InnerException.Message); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Cancel() { var scheduler = new OneshotScheduler(); @@ -947,7 +949,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Cancel() } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Success_With_State() { var scheduler = new OneshotScheduler(); @@ -965,7 +967,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Success_With_State() Assert.Equal("state", task.AsyncState); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Failure_With_State() { var scheduler = new OneshotScheduler(); @@ -984,7 +986,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Failure_With_State() Assert.Equal("state", task.AsyncState); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Cancel_With_State() { var scheduler = new OneshotScheduler(); @@ -1007,7 +1009,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Cancel_With_State() Assert.Equal("state", task.AsyncState); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Success_With_Cancellation() { var scheduler = new OneshotScheduler(); @@ -1023,7 +1025,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Success_With_Cancellation() Assert.True(task.IsCompleted); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Failure_With_Cancellation() { var scheduler = new OneshotScheduler(); @@ -1041,7 +1043,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Failure_With_Cancellation() Assert.Equal("failure", task.Exception.InnerException.Message); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Cancel_With_Cancellation() { var scheduler = new OneshotScheduler(); @@ -1063,7 +1065,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Cancel_With_Cancellation() Assert.Equal(new TaskCanceledException(task).CancellationToken, cts.Token); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Success_With_State_And_Cancellation() { var scheduler = new OneshotScheduler(); @@ -1081,7 +1083,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Success_With_State_And_Cancellati Assert.Equal("state", task.AsyncState); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Failure_With_State_And_Cancellation() { var scheduler = new OneshotScheduler(); @@ -1100,7 +1102,7 @@ public void ToTask_Scheduler_Resumed_On_Thread_Failure_With_State_And_Cancellati Assert.Equal("state", task.AsyncState); } - [Fact] + [TestMethod] public void ToTask_Scheduler_Resumed_On_Thread_Cancel_With_State_And_Cancellation() { var scheduler = new OneshotScheduler(); @@ -1168,7 +1170,7 @@ public void Dispose() } } - [Fact] + [TestMethod] public async Task ToTask_Scheduler_Dispose_Can_Propagate() { async Task asyncMethod() diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TimeTests.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TimeTests.cs index 9608e024cb..8897b300e3 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TimeTests.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/TimeTests.cs @@ -4,14 +4,16 @@ using System; using System.Reactive; -using Xunit; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +using Assert = Xunit.Assert; namespace ReactiveTests.Tests { - + [TestClass] public class TimeTests { - [Fact] + [TestMethod] public void TimeInterval_Ctor_Properties() { var ti = new TimeInterval(42, TimeSpan.FromSeconds(123.45)); @@ -19,7 +21,7 @@ public void TimeInterval_Ctor_Properties() Assert.Equal(TimeSpan.FromSeconds(123.45), ti.Interval); } - [Fact] + [TestMethod] public void TimeInterval_Equals() { var ti = new TimeInterval(42, TimeSpan.FromSeconds(123.45)); @@ -41,7 +43,7 @@ public void TimeInterval_Equals() Assert.True(((object)ti).Equals(t4)); } - [Fact] + [TestMethod] public void TimeInterval_GetHashCode() { var ti = new TimeInterval(null, TimeSpan.FromSeconds(123.45)); @@ -52,7 +54,7 @@ public void TimeInterval_GetHashCode() Assert.NotEqual(ti.GetHashCode(), t2.GetHashCode()); } - [Fact] + [TestMethod] public void TimeInterval_EqualsOperators() { var ti = new TimeInterval(42, TimeSpan.FromSeconds(123.45)); @@ -75,7 +77,7 @@ public void TimeInterval_EqualsOperators() Assert.False(t4 != ti); } - [Fact] + [TestMethod] public void TimeInterval_ToString() { var ti = new TimeInterval(42, TimeSpan.FromSeconds(123.45)); @@ -83,7 +85,7 @@ public void TimeInterval_ToString() Assert.True(ti.ToString().Contains(TimeSpan.FromSeconds(123.45).ToString())); } - [Fact] + [TestMethod] public void Timestamped_Create() { var o = DateTimeOffset.UtcNow; @@ -92,7 +94,7 @@ public void Timestamped_Create() Assert.Equal(o, ti.Timestamp); } - [Fact] + [TestMethod] public void Timestamped_Ctor_Properties() { var o = new DateTimeOffset(); @@ -101,7 +103,7 @@ public void Timestamped_Ctor_Properties() Assert.Equal(o, ti.Timestamp); } - [Fact] + [TestMethod] public void Timestamped_Equals() { var ti = new Timestamped(42, new DateTimeOffset()); @@ -123,7 +125,7 @@ public void Timestamped_Equals() Assert.True(((object)ti).Equals(t4)); } - [Fact] + [TestMethod] public void Timestamped_GetHashCode() { var ti = new Timestamped(null, new DateTimeOffset()); @@ -134,7 +136,7 @@ public void Timestamped_GetHashCode() Assert.NotEqual(ti.GetHashCode(), t2.GetHashCode()); } - [Fact] + [TestMethod] public void Timestamped_EqualsOperators() { var o = new DateTimeOffset(); @@ -159,7 +161,7 @@ public void Timestamped_EqualsOperators() Assert.False(t4 != ti); } - [Fact] + [TestMethod] public void Timestamped_ToString() { var o = new DateTimeOffset(); diff --git a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/UnitTest.cs b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/UnitTest.cs index 6b035f06a1..e540862140 100644 --- a/Rx.NET/Source/tests/Tests.System.Reactive/Tests/UnitTest.cs +++ b/Rx.NET/Source/tests/Tests.System.Reactive/Tests/UnitTest.cs @@ -3,14 +3,16 @@ // 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 UnitTest { - [Fact] + [TestMethod] public void Unit() { var u1 = new Unit(); diff --git a/azure-pipelines.rx.yml b/azure-pipelines.rx.yml index 69dc7c8ad9..3ebd298290 100644 --- a/azure-pipelines.rx.yml +++ b/azure-pipelines.rx.yml @@ -74,14 +74,14 @@ stages: inputs: command: test projects: Rx.NET/Source/tests/Tests.System.Reactive/*.csproj - arguments: -c $(BuildConfiguration) --filter "SkipCI!=true" --settings Rx.NET/Source/CodeCoverage.runsettings --collect:"XPlat Code Coverage" -- RunConfiguration.DisableAppDomain=true + arguments: -c $(BuildConfiguration) --filter "TestCategory!=SkipCI" --settings Rx.NET/Source/CodeCoverage.runsettings --collect:"XPlat Code Coverage" -- RunConfiguration.DisableAppDomain=true displayName: Run Unit Tests - task: DotNetCoreCLI@2 inputs: command: test projects: Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Tests.System.Reactive.ApiApprovals.csproj - arguments: -c $(BuildConfiguration) + arguments: -c $(BuildConfiguration) displayName: Run Api Approvals Tests - script: reportgenerator -reports:$(Agent.TempDirectory)/**/coverage.cobertura.xml -targetdir:$(Build.SourcesDirectory)/Rx.NET/Source/coverlet/reports -reporttypes:"Cobertura" @@ -155,14 +155,14 @@ stages: inputs: command: test projects: $(System.DefaultWorkingDirectory)/Rx.NET/Integration/LinuxTests/LinuxTests.csproj - arguments: -c $(BuildConfiguration) -f net7.0 --filter "SkipCI!=true" + arguments: -c $(BuildConfiguration) -f net7.0 --filter "TestCategory!=SkipCI" displayName: Run 7.0 Tests on Linux - task: DotNetCoreCLI@2 inputs: command: test projects: $(System.DefaultWorkingDirectory)/Rx.NET/Integration/LinuxTests/LinuxTests.csproj - arguments: -c $(BuildConfiguration) -f net6.0 --filter "SkipCI!=true" + arguments: -c $(BuildConfiguration) -f net6.0 --filter "TestCategory!=SkipCI" displayName: Run 6.0 Tests on Linux - job: WindowsDesktop @@ -208,7 +208,7 @@ stages: inputs: command: test projects: $(System.DefaultWorkingDirectory)/Rx.NET/Integration/WindowsDesktopTests/WindowsDesktopTests.csproj - arguments: -c $(BuildConfiguration) --filter "SkipCI!=true" + arguments: -c $(BuildConfiguration) --filter "TestCategory!=SkipCI" displayName: Run Tests on Window Desktop - stage: CodeSign