diff --git a/Directory.Build.props b/Directory.Build.props index e377b5041..9a9f29afb 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -4,6 +4,7 @@ enable $(WarningsAsErrors);nullable; + strict enable diff --git a/Directory.Packages.props b/Directory.Packages.props index b47646d48..f4dbe7ce0 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -5,8 +5,8 @@ - - + + @@ -23,17 +23,10 @@ - + + - - - - - - - - - + diff --git a/Source/SuperLinq.Async/SuperLinq.Async.csproj b/Source/SuperLinq.Async/SuperLinq.Async.csproj index 89225cb9d..89275d5b6 100644 --- a/Source/SuperLinq.Async/SuperLinq.Async.csproj +++ b/Source/SuperLinq.Async/SuperLinq.Async.csproj @@ -5,7 +5,6 @@ SuperLinq.Async SuperLinq.Async - netstandard2.0;$(TargetFrameworks) true @@ -21,9 +20,6 @@ true https://github.com/viceroypenguin/SuperLinq - - true - snupkg diff --git a/Source/SuperLinq/SuperLinq.csproj b/Source/SuperLinq/SuperLinq.csproj index 7abb386ba..b22ded194 100644 --- a/Source/SuperLinq/SuperLinq.csproj +++ b/Source/SuperLinq/SuperLinq.csproj @@ -5,7 +5,6 @@ SuperLinq SuperLinq - netstandard2.0;$(TargetFrameworks) true @@ -23,9 +22,6 @@ true https://github.com/viceroypenguin/SuperLinq - - true - snupkg @@ -167,7 +163,7 @@ - + diff --git a/SuperLinq.sln b/SuperLinq.sln index a02f6b0ec..91e71b88b 100644 --- a/SuperLinq.sln +++ b/SuperLinq.sln @@ -20,11 +20,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{99F4CCA1 EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SuperLinq", "Source\SuperLinq\SuperLinq.csproj", "{921016AA-80B6-44ED-8A92-E96601C92C4E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SuperLinq.Test", "Tests\SuperLinq.Test\SuperLinq.Test.csproj", "{674D18D8-CCE1-4102-AF6E-E6F993813422}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SuperLinq.Test", "Tests\SuperLinq.Tests\SuperLinq.Tests.csproj", "{674D18D8-CCE1-4102-AF6E-E6F993813422}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SuperLinq.Async", "Source\SuperLinq.Async\SuperLinq.Async.csproj", "{84058331-3025-438D-8A68-B55EE859C70D}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SuperLinq.Async.Test", "Tests\SuperLinq.Async.Test\SuperLinq.Async.Test.csproj", "{1A4F94C6-2143-486B-B787-271506C327FC}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SuperLinq.Async.Test", "Tests\SuperLinq.Async.Tests\SuperLinq.Async.Tests.csproj", "{1A4F94C6-2143-486B-B787-271506C327FC}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Generators", "Generators", "{7805222E-6CD5-41FE-9945-0D9FD7DFA24C}" EndProject diff --git a/TargetFrameworks.props b/TargetFrameworks.props index 635585bdb..e472b95ba 100644 --- a/TargetFrameworks.props +++ b/TargetFrameworks.props @@ -1,7 +1,7 @@ - netcoreapp3.1;net6.0 + netstandard2.0;netcoreapp3.1;net6.0 $(TargetFrameworks);net8.0 $(TargetFrameworks);net9.0 diff --git a/Tests/SuperLinq.Async.Test/CountDownTest.cs b/Tests/SuperLinq.Async.Test/CountDownTest.cs deleted file mode 100644 index 589662d26..000000000 --- a/Tests/SuperLinq.Async.Test/CountDownTest.cs +++ /dev/null @@ -1,47 +0,0 @@ -namespace Test.Async; - -public sealed class CountDownTest -{ - [Fact] - public void IsLazy() - { - _ = new AsyncBreakingSequence() - .CountDown(42, BreakingFunc.Of()); - } - - [Theory] - [InlineData(0), InlineData(-1)] - public void ExceptionOnNegativeCount(int param) - { - _ = Assert.Throws("count", () => - new AsyncBreakingSequence().CountDown(param)); - } - - private static IEnumerable GetData(Func selector) - { - var xs = Enumerable.Range(0, 5).ToArray(); - yield return selector(xs, 1, [null, null, null, null, 0]); - yield return selector(xs, 2, [null, null, null, 1, 0]); - yield return selector(xs, 3, [null, null, 2, 1, 0]); - yield return selector(xs, 4, [null, 3, 2, 1, 0]); - yield return selector(xs, 5, [4, 3, 2, 1, 0]); - yield return selector(xs, 6, [4, 3, 2, 1, 0]); - yield return selector(xs, 7, [4, 3, 2, 1, 0]); - } - - public static IEnumerable SequenceData { get; } = - from e in GetData((xs, count, countdown) => new - { - Source = xs, - Count = count, - Countdown = countdown, - }) - select new object[] { e.Source, e.Count, e.Source.Zip(e.Countdown, ValueTuple.Create) }; - - [Theory, MemberData(nameof(SequenceData))] - public async Task WithSequence(int[] xs, int count, IEnumerable<(int, int?)> expected) - { - await using var ts = xs.Select(SuperEnumerable.Identity).AsTestingSequence(); - await ts.CountDown(count, ValueTuple.Create).AssertSequenceEqual(expected); - } -} diff --git a/Tests/SuperLinq.Async.Test/DuplicatesTest.cs b/Tests/SuperLinq.Async.Test/DuplicatesTest.cs deleted file mode 100644 index 915b1c199..000000000 --- a/Tests/SuperLinq.Async.Test/DuplicatesTest.cs +++ /dev/null @@ -1,60 +0,0 @@ -namespace Test.Async; - -public sealed class DuplicatesTest -{ - [Fact] - public void DuplicatesIsLazy() - { - _ = new AsyncBreakingSequence().Duplicates(); - } - - [Theory] - [InlineData(new int[] { 1, 2, 3 }, new int[] { })] - [InlineData(new int[] { 1, 2, 1, 3, 1, 2, 1 }, new int[] { 1, 2 })] - [InlineData(new int[] { 3, 3, 2, 2, 1, 1 }, new int[] { 3, 2, 1 })] - public async Task DuplicatesBehavior(IEnumerable source, IEnumerable expected) - { - await using var ts = source.AsTestingSequence(); - - var result = ts.Duplicates(); - await result.AssertSequenceEqual(expected); - } - - public static IEnumerable GetStringParameters() - { - yield return new object[] - { - new string[] { "foo", "bar", "qux" }, - StringComparer.Ordinal, - Array.Empty(), - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.Ordinal, - Array.Empty(), - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - new string[] { "FOO" }, - }; - yield return new object[] - { - new string[] { "Bar", "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - new string[] { "FOO", "bar" }, - }; - } - - [Theory] - [MemberData(nameof(GetStringParameters))] - public async Task DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, IEnumerable expected) - { - await using var ts = source.AsTestingSequence(); - - var result = ts.Duplicates(comparer); - await result.AssertSequenceEqual(expected); - } -} diff --git a/Tests/SuperLinq.Async.Test/HasDuplicatesTest.cs b/Tests/SuperLinq.Async.Test/HasDuplicatesTest.cs deleted file mode 100644 index cc7b6aa49..000000000 --- a/Tests/SuperLinq.Async.Test/HasDuplicatesTest.cs +++ /dev/null @@ -1,63 +0,0 @@ -namespace Test.Async; - -public sealed class HasDuplicatesTest -{ - [Fact] - public async Task DuplicatesDoesNotEnumerateUnnecessarily() - { - using var ts = AsyncSeq(1, 2, 3).Concat(AsyncSeqExceptionAt(2)).AsTestingSequence(); - - var result = await ts.HasDuplicates(); - Assert.True(result); - } - - [Theory] - [InlineData(new int[] { 1, 2, 3 }, false)] - [InlineData(new int[] { 1, 2, 1, 3, 1, 2, 1 }, true)] - [InlineData(new int[] { 3, 3, 2, 2, 1, 1 }, true)] - public async Task DuplicatesBehavior(IEnumerable source, bool expected) - { - await using var ts = source.AsTestingSequence(); - - var result = await ts.HasDuplicates(); - Assert.Equal(expected, result); - } - - public static IEnumerable GetStringParameters() - { - yield return new object[] - { - new string[] { "foo", "bar", "qux" }, - StringComparer.Ordinal, - false, - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.Ordinal, - false, - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - true, - }; - yield return new object[] - { - new string[] { "Bar", "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - true, - }; - } - - [Theory] - [MemberData(nameof(GetStringParameters))] - public async Task DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, bool expected) - { - await using var ts = source.AsTestingSequence(); - - var result = await ts.HasDuplicates(comparer); - Assert.Equal(expected, result); - } -} diff --git a/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj b/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj deleted file mode 100644 index 248d2c840..000000000 --- a/Tests/SuperLinq.Async.Test/SuperLinq.Async.Test.csproj +++ /dev/null @@ -1,50 +0,0 @@ - - - - - - SuperLinq.Async.Test - SuperLinq.Async.Test - Test.Async - net47;$(TargetFrameworks) - - false - latest-recommended - - - - - - - - - - - - - - - - - - - - - - - - - - $(DefineConstants);NO_INDEX - - - - - - - - - - - - diff --git a/Tests/SuperLinq.Async.Test/.editorconfig b/Tests/SuperLinq.Async.Tests/.editorconfig similarity index 69% rename from Tests/SuperLinq.Async.Test/.editorconfig rename to Tests/SuperLinq.Async.Tests/.editorconfig index 385f3533f..7ce6967b6 100644 --- a/Tests/SuperLinq.Async.Test/.editorconfig +++ b/Tests/SuperLinq.Async.Tests/.editorconfig @@ -1,6 +1,7 @@ [*.cs] dotnet_diagnostic.CA1707.severity = none # CA1707: Identifiers should not contain underscores +dotnet_diagnostic.CA1822.severity = none # CA1822: Mark members as static dotnet_diagnostic.CA1861.severity = none # CA1861: Avoid constant arrays as arguments dotnet_diagnostic.CA2201.severity = none # CA2201: Do not raise reserved exception types @@ -11,9 +12,5 @@ dotnet_diagnostic.CS1573.severity = none # CS1573: Missing XML co dotnet_diagnostic.CS1591.severity = none # CS1591: Missing XML comment for publicly visible type or member dotnet_diagnostic.CS1712.severity = none # CS1712: Type parameter has no matching typeparam tag in the XML comment (but other type parameters do) -# xUnit errors -dotnet_diagnostic.xUnit1008.severity = error # xUnit1008: Test data attribute should only be used on a Theory -dotnet_diagnostic.xUnit1013.severity = error # xUnit1013: Public method should be marked as test -dotnet_diagnostic.xUnit1042.severity = none # xUnit1042: The member referenced by the MemberData attribute returns untyped data rows - dotnet_diagnostic.MA0046.severity = none +dotnet_diagnostic.TUnit0046.severity = none diff --git a/Tests/SuperLinq.Async.Test/AggregateByTest.cs b/Tests/SuperLinq.Async.Tests/AggregateByTest.cs similarity index 56% rename from Tests/SuperLinq.Async.Test/AggregateByTest.cs rename to Tests/SuperLinq.Async.Tests/AggregateByTest.cs index eddd8eb83..0f7de6baf 100644 --- a/Tests/SuperLinq.Async.Test/AggregateByTest.cs +++ b/Tests/SuperLinq.Async.Tests/AggregateByTest.cs @@ -1,144 +1,155 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class AggregateByTest { - [Theory] - [MemberData(nameof(AggregateBy_TestData))] - public static async Task AggregateBy_HasExpectedOutput( - IEnumerable source, - Func keySelector, - Func seedSelector, - Func func, - IEqualityComparer? comparer, - IEnumerable> expected) where TKey : notnull + [Test] + public static async Task AggregateBy() { - await using var ts = source.AsTestingSequence(); - await ts.AggregateBy(keySelector, seedSelector, func, comparer) - .AssertCollectionEqual(expected); - } - - public static IEnumerable AggregateBy_TestData() - { - yield return WrapArgs( + static async Task DoTest( + IEnumerable source, + Func keySelector, + Func seedSelector, + Func func, + IEqualityComparer? comparer, + IEnumerable> expected) where TKey : notnull + { + await using var ts = source.AsTestingSequence(); + await ts.AggregateBy(keySelector, seedSelector, func, comparer) + .AssertCollectionEqual(expected); + } + + await DoTest( source: Enumerable.Empty(), keySelector: x => x, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: []); + expected: [] + ); - yield return WrapArgs( + await DoTest( source: Enumerable.Range(0, 10), keySelector: x => x, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Range(0, 10).ToDictionary(x => x, x => x)); + expected: Enumerable.Range(0, 10).Select(x => KeyValuePair.Create(x, x)) + ); - yield return WrapArgs( + await DoTest( source: Enumerable.Range(5, 10), keySelector: x => true, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Repeat(true, 1).ToDictionary(x => x, x => 95)); + expected: [KeyValuePair.Create(key: true, 95)] + ); - yield return WrapArgs( + await DoTest( source: Enumerable.Range(0, 20), keySelector: x => x % 5, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Range(0, 5).ToDictionary(x => x, x => 30 + (4 * x))); + expected: Enumerable.Range(0, 5).Select(x => KeyValuePair.Create(x, 30 + (4 * x))) + ); - yield return WrapArgs( + await DoTest( source: Enumerable.Repeat(5, 20), keySelector: x => x, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Repeat(5, 1).ToDictionary(x => x, x => 100)); + expected: Enumerable.Repeat(5, 1).Select(x => KeyValuePair.Create(x, 100)) + ); - yield return WrapArgs( + await DoTest( source: ["Bob", "bob", "tim", "Bob", "Tim"], keySelector: x => x, seedSelector: x => "", func: (x, y) => x + y, comparer: null, - expected: new Dictionary(StringComparer.Ordinal) - { - { "Bob", "BobBob" }, - { "bob", "bob" }, - { "tim", "tim" }, - { "Tim", "Tim" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create("Bob", "BobBob"), + KeyValuePair.Create("bob", "bob"), + KeyValuePair.Create("tim", "tim"), + KeyValuePair.Create("Tim", "Tim"), + ] + ); + + await DoTest( source: ["Bob", "bob", "tim", "Bob", "Tim"], keySelector: x => x, seedSelector: x => "", func: (x, y) => x + y, StringComparer.OrdinalIgnoreCase, - expected: new Dictionary(StringComparer.Ordinal) - { - { "Bob", "BobbobBob" }, - { "tim", "timTim" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create("Bob", "BobbobBob"), + KeyValuePair.Create("tim", "timTim"), + ] + ); + + await DoTest( source: new (string Name, int Age)[] { ("Tom", 20), ("Dick", 30), ("Harry", 40) }, keySelector: x => x.Age, seedSelector: x => $"I am {x} and my name is ", func: (x, y) => x + y.Name, comparer: null, - expected: new Dictionary - { - { 20, "I am 20 and my name is Tom" }, - { 30, "I am 30 and my name is Dick" }, - { 40, "I am 40 and my name is Harry" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create(20, "I am 20 and my name is Tom"), + KeyValuePair.Create(30, "I am 30 and my name is Dick"), + KeyValuePair.Create(40, "I am 40 and my name is Harry"), + ] + ); + + await DoTest( source: new (string Name, int Age)[] { ("Tom", 20), ("Dick", 20), ("Harry", 40) }, keySelector: x => x.Age, seedSelector: x => $"I am {x} and my name is", func: (x, y) => $"{x} maybe {y.Name}", comparer: null, - expected: new Dictionary - { - { 20, "I am 20 and my name is maybe Tom maybe Dick" }, - { 40, "I am 40 and my name is maybe Harry" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create(20, "I am 20 and my name is maybe Tom maybe Dick"), + KeyValuePair.Create(40, "I am 40 and my name is maybe Harry"), + ] + ); + + await DoTest( source: new (string Name, int Age)[] { ("Bob", 20), ("bob", 20), ("Harry", 20) }, keySelector: x => x.Name, seedSelector: x => 0, func: (x, y) => x + y.Age, comparer: null, - expected: new string[] { "Bob", "bob", "Harry" } - .ToDictionary(x => x, x => 20, StringComparer.Ordinal)); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create("Bob", 20), + KeyValuePair.Create("bob", 20), + KeyValuePair.Create("Harry", 20), + ] + ); + + await DoTest( source: new (string Name, int Age)[] { ("Bob", 20), ("bob", 30), ("Harry", 40) }, keySelector: x => x.Name, seedSelector: x => 0, func: (x, y) => x + y.Age, comparer: StringComparer.OrdinalIgnoreCase, - expected: new Dictionary(StringComparer.Ordinal) - { - { "Bob", 50 }, - { "Harry", 40 }, - }); - - static object?[] WrapArgs(IEnumerable source, Func keySelector, Func seedSelector, Func func, IEqualityComparer? comparer, IEnumerable> expected) - => [source, keySelector, seedSelector, func, comparer, expected]; + expected: + [ + KeyValuePair.Create("Bob", 50), + KeyValuePair.Create("Harry", 40), + ] + ); } - [Fact] + [Test] public async Task GroupBy() { static IAsyncEnumerable>> GroupBy(IAsyncEnumerable source, Func keySelector) @@ -159,7 +170,7 @@ static IAsyncEnumerable>> GroupBy> LongCountBy(IAsyncEnumerable source, Func keySelector) @@ -182,7 +193,7 @@ await oddsEvens }); } - [Fact] + [Test] public async Task Score() { await using var data = TestingSequence.Of<(string id, int score)>( @@ -190,7 +201,8 @@ public async Task Score() ("1", 5), ("2", 4), ("1", 10), - ("0", 25)); + ("0", 25) + ); var scores = await data .AggregateBy( @@ -204,3 +216,18 @@ public async Task Score() Assert.Equal(4, scores["2"]); } } + +file static class KeyValuePair +{ + /// + /// Creates a new key/value pair instance using provided values. + /// + /// The key of the new to be created. + /// The value of the new to be created. + /// The type of the key. + /// The type of the value. + /// A key/value pair containing the provided arguments as values. + //Link: https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.keyvaluepair.create + public static KeyValuePair Create(TKey key, TValue value) => + new(key, value); +} diff --git a/Tests/SuperLinq.Async.Test/AggregateRightTest.cs b/Tests/SuperLinq.Async.Tests/AggregateRightTest.cs similarity index 91% rename from Tests/SuperLinq.Async.Test/AggregateRightTest.cs rename to Tests/SuperLinq.Async.Tests/AggregateRightTest.cs index f7ac7abbd..7b38849b0 100644 --- a/Tests/SuperLinq.Async.Test/AggregateRightTest.cs +++ b/Tests/SuperLinq.Async.Tests/AggregateRightTest.cs @@ -1,19 +1,19 @@ using System.Globalization; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class AggregateRightTest { // Overload 1 Test - [Fact] + [Test] public Task AggregateRightWithEmptySequence() { return Assert.ThrowsAsync( async () => await AsyncEnumerable.Empty().AggregateRight((a, b) => a + b)); } - [Fact] + [Test] public async Task AggregateRightFuncIsNotInvokedOnSingleElementSequence() { await using var enumerable = TestingSequence.Of(1); @@ -22,7 +22,7 @@ public async Task AggregateRightFuncIsNotInvokedOnSingleElementSequence() Assert.Equal(1, result); } - [Fact] + [Test] public async Task AggregateRight() { await using var enumerable = AsyncEnumerable.Range(1, 5).Select(x => x.ToString(CultureInfo.InvariantCulture)).AsTestingSequence(); @@ -31,17 +31,17 @@ public async Task AggregateRight() Assert.Equal("(1+(2+(3+(4+5))))", result); } - [Theory] - [InlineData(5)] - [InlineData("c")] - [InlineData(true)] + [Test] + [Arguments(5)] + [Arguments("c")] + [Arguments(true)] public async Task AggregateRightSeedWithEmptySequence(object defaultValue) { await using var enumerable = TestingSequence.Of(); Assert.Equal(defaultValue, await enumerable.AggregateRight(defaultValue, (a, b) => b)); } - [Fact] + [Test] public async Task AggregateRightSeedFuncIsNotInvokedOnEmptySequence() { await using var enumerable = TestingSequence.Of(); @@ -50,7 +50,7 @@ public async Task AggregateRightSeedFuncIsNotInvokedOnEmptySequence() Assert.Equal(1, result); } - [Fact] + [Test] public async Task AggregateRightSeed() { await using var enumerable = AsyncEnumerable.Range(1, 4).AsTestingSequence(); @@ -60,10 +60,10 @@ public async Task AggregateRightSeed() Assert.Equal("(1+(2+(3+(4+5))))", result); } - [Theory] - [InlineData(5)] - [InlineData("c")] - [InlineData(true)] + [Test] + [Arguments(5)] + [Arguments("c")] + [Arguments(true)] public async Task AggregateRightResultorWithEmptySequence(object defaultValue) { await using var enumerable = TestingSequence.Of(); @@ -72,7 +72,7 @@ public async Task AggregateRightResultorWithEmptySequence(object defaultValue) Assert.True(result); } - [Fact] + [Test] public async Task AggregateRightResultor() { await using var enumerable = AsyncEnumerable.Range(1, 4).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/AmbTest.cs b/Tests/SuperLinq.Async.Tests/AmbTest.cs similarity index 88% rename from Tests/SuperLinq.Async.Test/AmbTest.cs rename to Tests/SuperLinq.Async.Tests/AmbTest.cs index 307177af8..352292cf6 100644 --- a/Tests/SuperLinq.Async.Test/AmbTest.cs +++ b/Tests/SuperLinq.Async.Tests/AmbTest.cs @@ -1,21 +1,21 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class AmbTest { - [Fact] + [Test] public void AmbIsLazy() { _ = new AsyncBreakingSequence().Amb(new AsyncBreakingSequence()); _ = AsyncSuperEnumerable.Amb(new AsyncBreakingSequence(), new AsyncBreakingSequence()); } - [Theory] - [InlineData(1, false)] - [InlineData(2, false)] - [InlineData(3, false)] - [InlineData(1, true)] - [InlineData(2, true)] - [InlineData(3, true)] + [Test] + [Arguments(1, false)] + [Arguments(2, false)] + [Arguments(3, false)] + [Arguments(1, true)] + [Arguments(2, true)] + [Arguments(3, true)] public async Task AmbEmptyReturnsFirst(int sequenceNumber, bool asyncEmpty) { var empty = AsyncEnumerable.Empty(); @@ -41,10 +41,10 @@ public async Task AmbEmptyReturnsFirst(int sequenceNumber, bool asyncEmpty) await result.AssertSequenceEqual(); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] public async Task AmbSyncReturnsFirst(int sequenceNumber) { var sync = AsyncEnumerable.Range(1, 5); @@ -67,10 +67,10 @@ public async Task AmbSyncReturnsFirst(int sequenceNumber) await result.AssertSequenceEqual(Enumerable.Range(1, 5)); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] public async Task AmbAsyncShortestComesFirst(int sequenceNumber) { var shorter = AsyncEnumerable.Range(1, 5) diff --git a/Tests/SuperLinq.Async.Test/AssertCountTest.cs b/Tests/SuperLinq.Async.Tests/AssertCountTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/AssertCountTest.cs rename to Tests/SuperLinq.Async.Tests/AssertCountTest.cs index d111f7dfe..bcdbfbc29 100644 --- a/Tests/SuperLinq.Async.Test/AssertCountTest.cs +++ b/Tests/SuperLinq.Async.Tests/AssertCountTest.cs @@ -1,28 +1,28 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class AssertCountTest { - [Fact] + [Test] public void AssertCountIsLazy() { _ = new AsyncBreakingSequence().AssertCount(0); } - [Fact] + [Test] public void AssertCountNegativeCount() { _ = Assert.Throws("count", () => new AsyncBreakingSequence().AssertCount(-1)); } - [Fact] + [Test] public async Task AssertCountSequenceWithMatchingLength() { await using var data = TestingSequence.Of("foo", "bar", "baz"); await data.AssertCount(3).Consume(); } - [Fact] + [Test] public async Task AssertCountShortSequence() { await using var data = TestingSequence.Of("foo", "bar", "baz"); @@ -30,7 +30,7 @@ public async Task AssertCountShortSequence() await data.AssertCount(4).Consume()); } - [Fact] + [Test] public async Task AssertCountLongSequence() { await using var data = TestingSequence.Of("foo", "bar", "baz"); diff --git a/Tests/SuperLinq.Async.Test/AsyncBreakingFunc.cs b/Tests/SuperLinq.Async.Tests/AsyncBreakingFunc.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/AsyncBreakingFunc.cs rename to Tests/SuperLinq.Async.Tests/AsyncBreakingFunc.cs index 2e1649d78..aa6f07d9f 100644 --- a/Tests/SuperLinq.Async.Test/AsyncBreakingFunc.cs +++ b/Tests/SuperLinq.Async.Tests/AsyncBreakingFunc.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Functions which throw NotImplementedException if they're ever called. diff --git a/Tests/SuperLinq.Async.Test/AtLeastTest.cs b/Tests/SuperLinq.Async.Tests/AtLeastTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/AtLeastTest.cs rename to Tests/SuperLinq.Async.Tests/AtLeastTest.cs index f5b121f0e..d98919d24 100644 --- a/Tests/SuperLinq.Async.Test/AtLeastTest.cs +++ b/Tests/SuperLinq.Async.Tests/AtLeastTest.cs @@ -1,78 +1,78 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class AtLeastTest { - [Fact] + [Test] public async Task AtLeastWithNegativeCount() { _ = await Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().AtLeast(-1)); } - [Fact] + [Test] public async Task AtLeastWithEmptySequenceHasAtLeastZeroElements() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.True(await xs.AtLeast(0)); } - [Fact] + [Test] public async Task AtLeastWithEmptySequenceHasAtLeastOneElement() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.False(await xs.AtLeast(1)); } - [Fact] + [Test] public async Task AtLeastWithEmptySequenceHasAtLeastManyElements() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.False(await xs.AtLeast(2)); } - [Fact] + [Test] public async Task AtLeastWithSingleElementHasAtLeastZeroElements() { await using var xs = TestingSequence.Of(1); Assert.True(await xs.AtLeast(0)); } - [Fact] + [Test] public async Task AtLeastWithSingleElementHasAtLeastOneElement() { await using var xs = TestingSequence.Of(1); Assert.True(await xs.AtLeast(1)); } - [Fact] + [Test] public async Task AtLeastWithSingleElementHasAtLeastManyElements() { await using var xs = TestingSequence.Of(1); Assert.False(await xs.AtLeast(2)); } - [Fact] + [Test] public async Task AtLeastWithManyElementsHasAtLeastZeroElements() { await using var xs = TestingSequence.Of(1, 2, 3); Assert.True(await xs.AtLeast(0)); } - [Fact] + [Test] public async Task AtLeastWithManyElementsHasAtLeastOneElement() { await using var xs = TestingSequence.Of(1, 2, 3); Assert.True(await xs.AtLeast(1)); } - [Fact] + [Test] public async Task AtLeastWithManyElementsHasAtLeastManyElements() { await using var xs = TestingSequence.Of(1, 2, 3); Assert.True(await xs.AtLeast(2)); } - [Fact] + [Test] public async Task AtLeastDoesNotIterateUnnecessaryElements() { await using var xs = AsyncSeqExceptionAt(3).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/AtMostTest.cs b/Tests/SuperLinq.Async.Tests/AtMostTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/AtMostTest.cs rename to Tests/SuperLinq.Async.Tests/AtMostTest.cs index 99ac0b2d6..d9cfcd250 100644 --- a/Tests/SuperLinq.Async.Test/AtMostTest.cs +++ b/Tests/SuperLinq.Async.Tests/AtMostTest.cs @@ -1,57 +1,57 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class AtMostTest { - [Fact] + [Test] public async Task AtMostWithNegativeCount() { _ = await Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().AtMost(-1)); } - [Fact] + [Test] public async Task AtMostWithEmptySequenceHasAtMostZeroElements() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.True(await xs.AtMost(0)); } - [Fact] + [Test] public async Task AtMostWithEmptySequenceHasAtMostOneElement() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.True(await xs.AtMost(1)); } - [Fact] + [Test] public async Task AtMostWithSingleElementHasAtMostZeroElements() { await using var xs = TestingSequence.Of(1); Assert.False(await xs.AtMost(0)); } - [Fact] + [Test] public async Task AtMostWithSingleElementHasAtMostOneElement() { await using var xs = TestingSequence.Of(1); Assert.True(await xs.AtMost(1)); } - [Fact] + [Test] public async Task AtMostWithSingleElementHasAtMostManyElements() { await using var xs = TestingSequence.Of(1); Assert.True(await xs.AtMost(2)); } - [Fact] + [Test] public async Task AtMostWithManyElementsHasAtMostOneElements() { await using var xs = TestingSequence.Of(1, 2, 3); Assert.False(await xs.AtMost(1)); } - [Fact] + [Test] public async Task AtMostDoesNotIterateUnnecessaryElements() { await using var xs = AsyncSeqExceptionAt(4).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/BatchTest.cs b/Tests/SuperLinq.Async.Tests/BatchTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/BatchTest.cs rename to Tests/SuperLinq.Async.Tests/BatchTest.cs index a73ab7300..f043b12b4 100644 --- a/Tests/SuperLinq.Async.Test/BatchTest.cs +++ b/Tests/SuperLinq.Async.Tests/BatchTest.cs @@ -1,15 +1,15 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class BatchTest { - [Fact] + [Test] public void BatchIsLazy() { _ = new AsyncBreakingSequence().Batch(1); _ = new AsyncBreakingSequence().Buffer(1); } - [Fact] + [Test] public void BatchValidatesSize() { _ = Assert.Throws("size", @@ -17,7 +17,7 @@ public void BatchValidatesSize() .Batch(0)); } - [Fact] + [Test] public async Task BatchDoesNotReturnSameArrayInstance() { await using var seq = Enumerable.Range(1, 4).AsTestingSequence(); @@ -31,7 +31,7 @@ public async Task BatchDoesNotReturnSameArrayInstance() Assert.NotEqual(batch1, batch2); } - [Fact] + [Test] public async Task BatchWithEmptySource() { await using var seq = Enumerable.Empty().AsTestingSequence(); @@ -39,7 +39,7 @@ public async Task BatchWithEmptySource() await seq.AssertSequenceEqual(); } - [Fact] + [Test] public async Task BatchEvenlyDivisibleSequence() { await using var seq = Enumerable.Range(1, 9).AsTestingSequence(); @@ -52,7 +52,7 @@ public async Task BatchEvenlyDivisibleSequence() await reader.ReadEnd(); } - [Fact] + [Test] public async Task BatchUnevenlyDivisibleSequence() { await using var seq = Enumerable.Range(1, 9).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/BindByIndexTest.cs b/Tests/SuperLinq.Async.Tests/BindByIndexTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/BindByIndexTest.cs rename to Tests/SuperLinq.Async.Tests/BindByIndexTest.cs index abb04ee22..a7bb997eb 100644 --- a/Tests/SuperLinq.Async.Test/BindByIndexTest.cs +++ b/Tests/SuperLinq.Async.Tests/BindByIndexTest.cs @@ -1,15 +1,15 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class BindByIndexTest { - [Fact] + [Test] public void BindByIndexIsLazy() { _ = new AsyncBreakingSequence().BindByIndex(new AsyncBreakingSequence()); _ = new AsyncBreakingSequence().BindByIndex(new AsyncBreakingSequence(), BreakingFunc.Of(), BreakingFunc.Of()); } - [Fact] + [Test] public async Task BindByIndexDisposesEnumerators() { await using var seq1 = TestingSequence.Of(); @@ -17,7 +17,7 @@ public async Task BindByIndexDisposesEnumerators() await seq1.BindByIndex(seq2).AssertEmpty(); } - [Fact] + [Test] public async Task BindByIndexInOrder() { var indexes = AsyncSeq(1, 3, 5, 7, 9); @@ -27,7 +27,7 @@ public async Task BindByIndexInOrder() await seq1.BindByIndex(seq2).AssertSequenceEqual(indexes.Select(x => x + 1)); } - [Fact] + [Test] public async Task BindByIndexOutOfOrder() { var indexes = AsyncSeq(9, 7, 5, 3, 1); @@ -37,7 +37,7 @@ public async Task BindByIndexOutOfOrder() await seq1.BindByIndex(seq2).AssertSequenceEqual(indexes.Select(x => x + 1)); } - [Fact] + [Test] public async Task BindByIndexComplex() { var indexes = AsyncSeq(0, 1, 8, 9, 3, 4, 2); @@ -47,10 +47,10 @@ public async Task BindByIndexComplex() await seq1.BindByIndex(seq2).AssertSequenceEqual(indexes.Select(x => x + 1)); } - [Theory] - [InlineData(-1)] - [InlineData(10)] - [InlineData(100)] + [Test] + [Arguments(-1)] + [Arguments(10)] + [Arguments(100)] public async Task BindByIndexThrowExceptionInvalidIndex(int index) { await using var seq1 = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -60,7 +60,7 @@ public async Task BindByIndexThrowExceptionInvalidIndex(int index) async () => await seq1.BindByIndex(seq2).Consume()); } - [Fact] + [Test] public async Task BindByIndexTransformInOrder() { var indexes = AsyncSeq(1, 3, 5, 7, 9); @@ -71,7 +71,7 @@ public async Task BindByIndexTransformInOrder() .AssertSequenceEqual(indexes.Select(x => (int?)(x + 1))); } - [Fact] + [Test] public async Task BindByIndexTransformOutOfOrder() { var indexes = AsyncSeq(9, 7, 5, 3, 1); @@ -82,7 +82,7 @@ public async Task BindByIndexTransformOutOfOrder() .AssertSequenceEqual(indexes.Select(x => (int?)(x + 1))); } - [Fact] + [Test] public async Task BindByIndexTransformComplex() { var indexes = AsyncSeq(0, 1, 8, 9, 3, 4, 2); @@ -93,7 +93,7 @@ public async Task BindByIndexTransformComplex() .AssertSequenceEqual(indexes.Select(x => (int?)(x + 1))); } - [Fact] + [Test] public async Task BindByIndexTransformInvalidIndex() { await using var seq1 = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -103,7 +103,7 @@ public async Task BindByIndexTransformInvalidIndex() .AssertSequenceEqual(2, null, 4, null); } - [Fact] + [Test] public async Task BindByIndexTransformThrowExceptionNegativeIndex() { await using var seq1 = AsyncEnumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/BreakingSequence.cs b/Tests/SuperLinq.Async.Tests/BreakingSequence.cs similarity index 91% rename from Tests/SuperLinq.Async.Test/BreakingSequence.cs rename to Tests/SuperLinq.Async.Tests/BreakingSequence.cs index 2ba4c8d9d..138ccd01a 100644 --- a/Tests/SuperLinq.Async.Test/BreakingSequence.cs +++ b/Tests/SuperLinq.Async.Tests/BreakingSequence.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Enumerable sequence which throws InvalidOperationException as soon as its enumerator is requested. Used to check diff --git a/Tests/SuperLinq.Async.Test/BufferTest.cs b/Tests/SuperLinq.Async.Tests/BufferTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/BufferTest.cs rename to Tests/SuperLinq.Async.Tests/BufferTest.cs index 5d7b80931..5ba4b26d3 100644 --- a/Tests/SuperLinq.Async.Test/BufferTest.cs +++ b/Tests/SuperLinq.Async.Tests/BufferTest.cs @@ -1,28 +1,28 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class BufferTest { - [Fact] + [Test] public void BufferIsLazy() { _ = new AsyncBreakingSequence().Buffer(2, 1); } - [Fact] + [Test] public void BufferValidatesCount() { _ = Assert.Throws("count", () => new AsyncBreakingSequence().Buffer(0, 2)); } - [Fact] + [Test] public void BufferValidatesSkip() { _ = Assert.Throws("skip", () => new AsyncBreakingSequence().Buffer(2, 0)); } - [Fact] + [Test] public async Task BufferEmptySequence() { await using var seq = Enumerable.Empty().AsTestingSequence(); @@ -31,10 +31,10 @@ public async Task BufferEmptySequence() await result.AssertSequenceEqual(); } - [Theory] - [InlineData(3)] - [InlineData(5)] - [InlineData(7)] + [Test] + [Arguments(3)] + [Arguments(5)] + [Arguments(7)] public async Task BufferNonOverlappingBuffers(int count) { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -47,7 +47,7 @@ public async Task BufferNonOverlappingBuffers(int count) } } - [Fact] + [Test] public async Task BufferOverlappingBuffers() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -61,7 +61,7 @@ public async Task BufferOverlappingBuffers() await reader.ReadEnd(); } - [Fact] + [Test] public async Task BufferSkippingBuffers() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/CaseTest.cs b/Tests/SuperLinq.Async.Tests/CaseTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/CaseTest.cs rename to Tests/SuperLinq.Async.Tests/CaseTest.cs index 3bec9086e..83731d998 100644 --- a/Tests/SuperLinq.Async.Test/CaseTest.cs +++ b/Tests/SuperLinq.Async.Tests/CaseTest.cs @@ -1,15 +1,15 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CaseTest { - [Fact] + [Test] public void CaseIsLazy() { _ = AsyncSuperEnumerable.Case(BreakingFunc.Of(), new Dictionary>()); _ = AsyncSuperEnumerable.Case(BreakingFunc.Of>(), new Dictionary>()); } - [Fact] + [Test] public async Task CaseBehavior() { var starts = 0; @@ -35,14 +35,14 @@ public async Task CaseBehavior() await seq.AssertSequenceEqual(); } - [Fact] + [Test] public void CaseSourceIsLazy() { _ = AsyncSuperEnumerable.Case(BreakingFunc.Of(), new Dictionary>(), new AsyncBreakingSequence()); _ = AsyncSuperEnumerable.Case(BreakingFunc.Of>(), new Dictionary>(), new AsyncBreakingSequence()); } - [Fact] + [Test] public async Task CaseSourceBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Async.Test/CatchTest.cs b/Tests/SuperLinq.Async.Tests/CatchTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/CatchTest.cs rename to Tests/SuperLinq.Async.Tests/CatchTest.cs index 049a8ab92..5c91f45ab 100644 --- a/Tests/SuperLinq.Async.Test/CatchTest.cs +++ b/Tests/SuperLinq.Async.Tests/CatchTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CatchTest { - [Fact] + [Test] public void CatchIsLazy() { _ = new AsyncBreakingSequence().Catch(BreakingFunc.Of>()); @@ -11,7 +11,7 @@ public void CatchIsLazy() _ = new[] { new AsyncBreakingSequence(), new AsyncBreakingSequence() }.Catch(); } - [Fact] + [Test] public async Task CatchThrowsDelayedExceptionOnNullSource() { var seq = AsyncSuperEnumerable.Catch(new IAsyncEnumerable[] { null! }); @@ -19,7 +19,7 @@ public async Task CatchThrowsDelayedExceptionOnNullSource() await seq.Consume()); } - [Fact] + [Test] public async Task CatchHandlerWithNoExceptions() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -28,7 +28,7 @@ public async Task CatchHandlerWithNoExceptions() await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public async Task CatchHandlerWithException() { await using var seq = AsyncSeqExceptionAt(5).AsTestingSequence(); @@ -46,7 +46,7 @@ public async Task CatchHandlerWithException() Assert.True(ran); } - [Fact] + [Test] public async Task CatchWithEmptySequenceList() { await using var seq = Enumerable.Empty>().AsTestingSequence(); @@ -55,10 +55,10 @@ public async Task CatchWithEmptySequenceList() await result.AssertSequenceEqual(); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] public async Task CatchMultipleSequencesNoExceptions(int count) { await using var ts1 = Enumerable.Range(1, 10).AsTestingSequence(); @@ -75,10 +75,10 @@ public async Task CatchMultipleSequencesNoExceptions(int count) await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Theory] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] + [Test] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] public async Task CatchMultipleSequencesWithNoExceptionOnSequence(int sequenceNumber) { var cnt = 1; @@ -98,7 +98,7 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(1, 10))); } - [Fact] + [Test] public async Task CatchMultipleSequencesThrowsIfNoFollowingSequence() { await using var ts1 = AsyncSeqExceptionAt(5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ChooseTest.cs b/Tests/SuperLinq.Async.Tests/ChooseTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/ChooseTest.cs rename to Tests/SuperLinq.Async.Tests/ChooseTest.cs index 3c44a6150..c4f6cefdf 100644 --- a/Tests/SuperLinq.Async.Test/ChooseTest.cs +++ b/Tests/SuperLinq.Async.Tests/ChooseTest.cs @@ -1,17 +1,17 @@ using System.Globalization; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ChooseTest { - [Fact] + [Test] public void IsLazy() { _ = new AsyncBreakingSequence() .Choose(BreakingFunc.Of()); } - [Fact] + [Test] public async Task WithEmptySource() { await using var xs = TestingSequence.Of(); @@ -19,14 +19,14 @@ public async Task WithEmptySource() .ToListAsync()); } - [Fact] + [Test] public async Task None() { await using var xs = Enumerable.Range(1, 10).AsTestingSequence(); Assert.Empty(await xs.Choose(_ => (false, 0)).ToListAsync()); } - [Fact] + [Test] public async Task ThoseParsable() { await using var xs = @@ -41,7 +41,7 @@ await xs .AssertSequenceEqual(2, 3, 4, 6, 7, 9); } - [Fact] + [Test] public async Task ThoseThatAreIntegers() { await using var xs = TestingSequence.Of(4, 1, 2, null, 4, null, 6, null, null, 9); @@ -50,7 +50,7 @@ await xs.Choose(e => e is { } n ? (true, n) : (false, default)) .AssertSequenceEqual(4, 1, 2, 4, 6, 9); } - [Fact] + [Test] public async Task ThoseEven() { await using var xs = AsyncEnumerable.Range(1, 10) diff --git a/Tests/SuperLinq.Async.Test/CollectionEqualTest.cs b/Tests/SuperLinq.Async.Tests/CollectionEqualTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/CollectionEqualTest.cs rename to Tests/SuperLinq.Async.Tests/CollectionEqualTest.cs index 1131deab2..56b55f412 100644 --- a/Tests/SuperLinq.Async.Test/CollectionEqualTest.cs +++ b/Tests/SuperLinq.Async.Tests/CollectionEqualTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CollectionEqualTest { - [Fact] + [Test] public async Task CollectionEqualIntSequenceInOrder() { await using var xs = TestingSequence.Of(1, 2, 3); @@ -10,7 +10,7 @@ public async Task CollectionEqualIntSequenceInOrder() Assert.True(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualIntSequenceOutOfOrder() { await using var xs = TestingSequence.Of(1, 2, 3); @@ -18,7 +18,7 @@ public async Task CollectionEqualIntSequenceOutOfOrder() Assert.True(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualIntSequenceDuplicate() { await using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -26,7 +26,7 @@ public async Task CollectionEqualIntSequenceDuplicate() Assert.True(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualIntDifferentSequence() { await using var xs = TestingSequence.Of(1, 2, 3); @@ -34,7 +34,7 @@ public async Task CollectionEqualIntDifferentSequence() Assert.False(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualIntDifferentDuplicate() { await using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -42,7 +42,7 @@ public async Task CollectionEqualIntDifferentDuplicate() Assert.False(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualStringSequenceInOrder() { await using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -50,7 +50,7 @@ public async Task CollectionEqualStringSequenceInOrder() Assert.True(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualStringSequenceOutOfOrder() { await using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -58,7 +58,7 @@ public async Task CollectionEqualStringSequenceOutOfOrder() Assert.True(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualStringSequenceDuplicate() { await using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); @@ -66,7 +66,7 @@ public async Task CollectionEqualStringSequenceDuplicate() Assert.True(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualStringDifferentSequence() { await using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -74,7 +74,7 @@ public async Task CollectionEqualStringDifferentSequence() Assert.False(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualStringDifferentDuplicate() { await using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); @@ -82,7 +82,7 @@ public async Task CollectionEqualStringDifferentDuplicate() Assert.False(await xs.CollectionEqual(ys)); } - [Fact] + [Test] public async Task CollectionEqualIntSequenceInOrderComparer() { await using var xs = TestingSequence.Of(1, 2, 3); @@ -91,7 +91,7 @@ public async Task CollectionEqualIntSequenceInOrderComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public async Task CollectionEqualIntSequenceOutOfOrderComparer() { await using var xs = TestingSequence.Of(1, 2, 3); @@ -100,7 +100,7 @@ public async Task CollectionEqualIntSequenceOutOfOrderComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public async Task CollectionEqualIntSequenceDuplicateComparer() { await using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -109,7 +109,7 @@ public async Task CollectionEqualIntSequenceDuplicateComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public async Task CollectionEqualIntDifferentSequenceComparer() { await using var xs = TestingSequence.Of(1, 2, 3); @@ -118,7 +118,7 @@ public async Task CollectionEqualIntDifferentSequenceComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public async Task CollectionEqualIntDifferentDuplicateComparer() { await using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -127,7 +127,7 @@ public async Task CollectionEqualIntDifferentDuplicateComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public async Task CollectionEqualStringSequenceInOrderComparer() { await using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -135,7 +135,7 @@ public async Task CollectionEqualStringSequenceInOrderComparer() Assert.True(await xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public async Task CollectionEqualStringSequenceOutOfOrderComparer() { await using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -143,7 +143,7 @@ public async Task CollectionEqualStringSequenceOutOfOrderComparer() Assert.True(await xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public async Task CollectionEqualStringSequenceDuplicateComparer() { await using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); @@ -151,7 +151,7 @@ public async Task CollectionEqualStringSequenceDuplicateComparer() Assert.True(await xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public async Task CollectionEqualStringDifferentSequenceComparer() { await using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -159,7 +159,7 @@ public async Task CollectionEqualStringDifferentSequenceComparer() Assert.False(await xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public async Task CollectionEqualStringDifferentDuplicateComparer() { await using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); diff --git a/Tests/SuperLinq.Async.Test/CompareCountTest.cs b/Tests/SuperLinq.Async.Tests/CompareCountTest.cs similarity index 84% rename from Tests/SuperLinq.Async.Test/CompareCountTest.cs rename to Tests/SuperLinq.Async.Tests/CompareCountTest.cs index 4cdc2f4b2..1e714dc9e 100644 --- a/Tests/SuperLinq.Async.Test/CompareCountTest.cs +++ b/Tests/SuperLinq.Async.Tests/CompareCountTest.cs @@ -1,12 +1,12 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CompareCountTest { - [Theory] - [InlineData(0, 0, 0)] - [InlineData(0, 1, -1)] - [InlineData(1, 0, 1)] - [InlineData(1, 1, 0)] + [Test] + [Arguments(0, 0, 0)] + [Arguments(0, 1, -1)] + [Arguments(1, 0, 1)] + [Arguments(1, 1, 0)] public async Task CompareCount(int xCount, int yCount, int expected) { await using var xs = AsyncEnumerable.Range(0, xCount).AsTestingSequence(); @@ -14,7 +14,7 @@ public async Task CompareCount(int xCount, int yCount, int expected) Assert.Equal(expected, await xs.CompareCount(ys)); } - [Fact] + [Test] public async Task CompareCountDisposesSequenceEnumerators() { await using var seq1 = TestingSequence.Of(); @@ -23,7 +23,7 @@ public async Task CompareCountDisposesSequenceEnumerators() Assert.Equal(0, await seq1.CompareCount(seq2)); } - [Fact] + [Test] public async Task CompareCountDoesNotIterateUnnecessaryElements() { await using var seq1 = AsyncSeqExceptionAt(5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ConcurrentMergeTest.cs b/Tests/SuperLinq.Async.Tests/ConcurrentMergeTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/ConcurrentMergeTest.cs rename to Tests/SuperLinq.Async.Tests/ConcurrentMergeTest.cs index 354690dfa..99900000f 100644 --- a/Tests/SuperLinq.Async.Test/ConcurrentMergeTest.cs +++ b/Tests/SuperLinq.Async.Tests/ConcurrentMergeTest.cs @@ -1,21 +1,21 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ConcurrentMergeTest { - [Fact] + [Test] public void ConcurrentMergeIsLazy() { _ = new AsyncBreakingSequence().ConcurrentMerge(new AsyncBreakingSequence()); } - [Fact] + [Test] public void ConcurrentMergeNegativeMaxConcurrency() { _ = Assert.Throws("maxConcurrency", () => new[] { new AsyncBreakingSequence() }.ConcurrentMerge(-1)); } - [Fact] + [Test] public async Task ConcurrentMergeDisposesOnErrorAtGetEnumerator() { await using var sequenceA = TestingSequence.Of(); @@ -26,7 +26,7 @@ public async Task ConcurrentMergeDisposesOnErrorAtGetEnumerator() await sequenceA.ConcurrentMerge(sequenceB).Consume()); } - [Fact] + [Test] public async Task ConcurrentMergeDisposesOnErrorAtMoveNext() { await using var sequenceA = TestingSequence.Of(); @@ -38,7 +38,7 @@ public async Task ConcurrentMergeDisposesOnErrorAtMoveNext() await sequenceA.ConcurrentMerge(sequenceB).Consume()); } - [Fact] + [Test] public async Task ConcurrentMergeTwoBalancedSequences() { await using var sequenceA = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -50,7 +50,7 @@ await result.AssertCollectionEqual( Enumerable.Range(1, 10).SelectMany(x => Enumerable.Repeat(x, 2))); } - [Fact] + [Test] public async Task ConcurrentMergeTwoEmptySequences() { await using var sequenceA = AsyncEnumerable.Empty().AsTestingSequence(); @@ -60,7 +60,7 @@ public async Task ConcurrentMergeTwoEmptySequences() await result.AssertSequenceEqual(Enumerable.Empty()); } - [Fact] + [Test] public async Task ConcurrentMergeTwoImbalanceStrategySkip() { await using var sequenceA = TestingSequence.Of(0, 0, 0, 0, 0, 0); @@ -71,7 +71,7 @@ public async Task ConcurrentMergeTwoImbalanceStrategySkip() await result.AssertCollectionEqual(0, 1, 0, 1, 0, 1, 0, 1, 0, 0); } - [Fact] + [Test] public async Task ConcurrentMergeManyEmptySequences() { await using var sequenceA = AsyncEnumerable.Empty().AsTestingSequence(); @@ -86,7 +86,8 @@ public async Task ConcurrentMergeManyEmptySequences() // excess time consumption - avoid unless explicit // shorter times introduce variability in ordering - [Fact(Skip = "Explicit")] + [Test] + [Explicit] public async Task ConcurrentMergeReturnsInOrderOfDelay() { await using var seqA = AsyncSuperEnumerable @@ -96,6 +97,7 @@ public async Task ConcurrentMergeReturnsInOrderOfDelay() async () => { await Task.Delay(300); return 3; }, // 600 async () => { await Task.Delay(400); return 4; }) // 1000 .AsTestingSequence(); + await using var seqB = AsyncSuperEnumerable .From( async () => { await Task.Delay(400); return 1; }, // 400 @@ -103,6 +105,7 @@ public async Task ConcurrentMergeReturnsInOrderOfDelay() async () => { await Task.Delay(200); return 3; }, // 900 async () => { await Task.Delay(100); return 4; }) // 1000 .AsTestingSequence(); + var result = seqA.ConcurrentMerge(seqB); await result.AssertSequenceEqual(1, 2, 1, 3, 2, 3, 4, 4); @@ -110,7 +113,8 @@ public async Task ConcurrentMergeReturnsInOrderOfDelay() // excess time consumption - avoid unless explicit // shorter times introduce variability in ordering - [Fact(Skip = "Explicit")] + [Test] + [Explicit] public async Task ConcurrentMergeReturnsInOrderOfDelayUnbounded() { await using var seqA = AsyncSuperEnumerable @@ -141,12 +145,13 @@ public async Task ConcurrentMergeReturnsInOrderOfDelayUnbounded() async () => { await Task.Delay(100); return 43; }, // 1000 async () => { await Task.Delay(500); return 44; }) // 1500 .AsTestingSequence(); + var result = new[] { seqA, seqB, seqC, seqD }.ConcurrentMerge(); await result.AssertSequenceEqual(31, 11, 41, 32, 12, 33, 21, 42, 43, 13, 22, 44, 34, 23, 24, 14); } - [Fact] + [Test] public async Task ConcurrentMergeReturnsWithDelayReturnsAllElementsUnbounded() { await using var seqA = AsyncSuperEnumerable @@ -182,7 +187,7 @@ public async Task ConcurrentMergeReturnsWithDelayReturnsAllElementsUnbounded() await result.AssertCollectionEqual(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, 44); } - [Fact] + [Test] public async Task ConcurrentMergeReturnsWithDelayReturnsAllElementsBounded() { await using var seqA = AsyncSuperEnumerable @@ -218,7 +223,7 @@ public async Task ConcurrentMergeReturnsWithDelayReturnsAllElementsBounded() await result.AssertCollectionEqual(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, 44); } - [Fact] + [Test] public async Task ConcurrentMergeSingleConcurrencyOperatesLikeInterleave() { await using var seqA = AsyncSuperEnumerable diff --git a/Tests/SuperLinq.Async.Test/ConsumeTest.cs b/Tests/SuperLinq.Async.Tests/ConsumeTest.cs similarity index 85% rename from Tests/SuperLinq.Async.Test/ConsumeTest.cs rename to Tests/SuperLinq.Async.Tests/ConsumeTest.cs index 5731124eb..ce3261561 100644 --- a/Tests/SuperLinq.Async.Test/ConsumeTest.cs +++ b/Tests/SuperLinq.Async.Tests/ConsumeTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ConsumeTest { - [Fact] + [Test] public async Task ConsumeReallyConsumes() { var counter = 0; diff --git a/Tests/SuperLinq.Async.Test/CopyToTest.cs b/Tests/SuperLinq.Async.Tests/CopyToTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/CopyToTest.cs rename to Tests/SuperLinq.Async.Tests/CopyToTest.cs index d24a1f101..1819a2143 100644 --- a/Tests/SuperLinq.Async.Test/CopyToTest.cs +++ b/Tests/SuperLinq.Async.Tests/CopyToTest.cs @@ -1,11 +1,11 @@ using System.Collections.ObjectModel; using System.Diagnostics.CodeAnalysis; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CopyToTest { - [Fact] + [Test] public async Task NullArgumentTest() { _ = await Assert.ThrowsAsync( @@ -22,7 +22,7 @@ public async Task NullArgumentTest() async () => await AsyncSeq().CopyTo(default(int[])!, 1)); } - [Fact] + [Test] public Task ThrowsOnNegativeIndex() { return Assert.ThrowsAsync( @@ -30,7 +30,7 @@ public Task ThrowsOnNegativeIndex() async () => await AsyncSeq().CopyTo([], -1)); } - [Fact] + [Test] [SuppressMessage( "Style", "IDE0301:Simplify collection initialization", @@ -42,7 +42,7 @@ public Task ThrowsOnTooMuchDataForArray() async () => await AsyncSeq(1).CopyTo(Array.Empty())); } - [Fact] + [Test] public async Task CopiesDataToArray() { var array = new int[4]; @@ -62,7 +62,7 @@ public async Task CopiesDataToArray() } } - [Fact] + [Test] public async Task CopiesDataToList() { var list = new List(); @@ -89,7 +89,7 @@ public async Task CopiesDataToList() } } - [Fact] + [Test] public async Task CopiesDataToIList() { var list = new Collection(); diff --git a/Tests/SuperLinq.Async.Test/CountBetweenTest.cs b/Tests/SuperLinq.Async.Tests/CountBetweenTest.cs similarity index 83% rename from Tests/SuperLinq.Async.Test/CountBetweenTest.cs rename to Tests/SuperLinq.Async.Tests/CountBetweenTest.cs index 37754292e..7813615f5 100644 --- a/Tests/SuperLinq.Async.Test/CountBetweenTest.cs +++ b/Tests/SuperLinq.Async.Tests/CountBetweenTest.cs @@ -1,48 +1,48 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CountBetweenTest { - [Fact] + [Test] public Task CountBetweenWithNegativeMin() { return Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().CountBetween(-1, 0)); } - [Fact] + [Test] public Task CountBetweenWithNegativeMax() { return Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().CountBetween(0, -1)); } - [Fact] + [Test] public Task CountBetweenWithMaxLesserThanMin() { return Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().CountBetween(1, 0)); } - [Fact] + [Test] public async Task CountBetweenWithMaxEqualsMin() { await using var xs = TestingSequence.Of(1); Assert.True(await xs.CountBetween(1, 1)); } - [Theory] - [InlineData(1, 2, 4, false)] - [InlineData(2, 2, 4, true)] - [InlineData(3, 2, 4, true)] - [InlineData(4, 2, 4, true)] - [InlineData(5, 2, 4, false)] + [Test] + [Arguments(1, 2, 4, false)] + [Arguments(2, 2, 4, true)] + [Arguments(3, 2, 4, true)] + [Arguments(4, 2, 4, true)] + [Arguments(5, 2, 4, false)] public async Task CountBetweenRangeTests(int count, int min, int max, bool expecting) { await using var xs = AsyncEnumerable.Range(1, count).AsTestingSequence(); Assert.Equal(expecting, await xs.CountBetween(min, max)); } - [Fact] + [Test] public async Task CountBetweenDoesNotIterateUnnecessaryElements() { await using var xs = AsyncSeqExceptionAt(5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/CountByTest.cs b/Tests/SuperLinq.Async.Tests/CountByTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/CountByTest.cs rename to Tests/SuperLinq.Async.Tests/CountByTest.cs index d3d078d49..84ec3694a 100644 --- a/Tests/SuperLinq.Async.Test/CountByTest.cs +++ b/Tests/SuperLinq.Async.Tests/CountByTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class CountByTest { - [Fact] + [Test] public async Task CountBySimpleTest() { await using var xs = TestingSequence.Of(1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 1, 2); @@ -17,7 +17,7 @@ await xs.CountBy(SuperEnumerable.Identity) CreatePair(6, 1)); } - [Fact] + [Test] public async Task CountByWithSecondOccurenceImmediatelyAfterFirst() { await using var xs = "jaffer".AsTestingSequence(); @@ -31,7 +31,7 @@ await xs.CountBy(SuperEnumerable.Identity) CreatePair('r', 1)); } - [Fact] + [Test] public async Task CountByEvenOddTest() { await using var xs = AsyncEnumerable.Range(1, 100) @@ -44,7 +44,7 @@ await xs CreatePair(0, 50)); } - [Fact] + [Test] public async Task CountByWithEqualityComparer() { await using var xs = TestingSequence.Of("a", "B", "c", "A", "b", "A"); @@ -57,7 +57,7 @@ await xs CreatePair("c", 1)); } - [Fact] + [Test] public async Task CountByHasKeysOrderedLikeGroupBy() { var randomSequence = SuperLinq.SuperEnumerable.Random(0, 100).Take(100).ToArray(); @@ -69,14 +69,14 @@ public async Task CountByHasKeysOrderedLikeGroupBy() await countByKeys.AssertSequenceEqual(groupByKeys); } - [Fact] + [Test] public void CountByIsLazy() { _ = new AsyncBreakingSequence() .CountBy(AsyncBreakingFunc.Of()); } - [Fact] + [Test] public async Task CountByWithSomeNullKeys() { await using var ss = TestingSequence.Of("foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"); diff --git a/Tests/SuperLinq.Async.Tests/CountDownTest.cs b/Tests/SuperLinq.Async.Tests/CountDownTest.cs new file mode 100644 index 000000000..5489d75d3 --- /dev/null +++ b/Tests/SuperLinq.Async.Tests/CountDownTest.cs @@ -0,0 +1,41 @@ +namespace SuperLinq.Async.Tests; + +public sealed class CountDownTest +{ + [Test] + public void IsLazy() + { + _ = new AsyncBreakingSequence() + .CountDown(42, BreakingFunc.Of()); + } + + [Test] + [Arguments(0), Arguments(-1)] + public void ExceptionOnNegativeCount(int param) + { + _ = Assert.Throws("count", () => + new AsyncBreakingSequence().CountDown(param)); + } + + public static IEnumerable<(IEnumerable seq, int count, IEnumerable<(int, int?)> expected)> GetTestCases() + { + var xs = Enumerable.Range(0, 5).ToList(); + + for (var i = 1; i <= 7; i++) + { + var countdown = i < 5 + ? Enumerable.Repeat(null, 5 - i).Concat(Enumerable.Range(0, i).Cast().Reverse()) + : Enumerable.Range(0, 5).Cast().Reverse(); + + yield return (xs, i, xs.EquiZip(countdown)); + } + } + + [Test] + [MethodDataSource(nameof(GetTestCases))] + public async Task WithSequence(IEnumerable xs, int count, IEnumerable<(int, int?)> expected) + { + await using var ts = xs.Select(SuperEnumerable.Identity).AsTestingSequence(); + await ts.CountDown(count, ValueTuple.Create).AssertSequenceEqual(expected); + } +} diff --git a/Tests/SuperLinq.Async.Test/DeferTest.cs b/Tests/SuperLinq.Async.Tests/DeferTest.cs similarity index 91% rename from Tests/SuperLinq.Async.Test/DeferTest.cs rename to Tests/SuperLinq.Async.Tests/DeferTest.cs index cda9bf5b4..bd1e2f6b6 100644 --- a/Tests/SuperLinq.Async.Test/DeferTest.cs +++ b/Tests/SuperLinq.Async.Tests/DeferTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DeferTest { - [Fact] + [Test] public void DeferIsLazy() { _ = AsyncSuperEnumerable.Defer(BreakingFunc.Of>()); } - [Fact] + [Test] public async Task DeferBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs b/Tests/SuperLinq.Async.Tests/DensePartialSortByTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs rename to Tests/SuperLinq.Async.Tests/DensePartialSortByTest.cs index eb7476bd0..8f7914d82 100644 --- a/Tests/SuperLinq.Async.Test/DensePartialSortByTest.cs +++ b/Tests/SuperLinq.Async.Tests/DensePartialSortByTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DensePartialSortByTests { - [Fact] + [Test] public void DensePartialSortByIsLazy() { _ = new AsyncBreakingSequence().DensePartialSortBy(1, BreakingFunc.Of()); } - [Fact] + [Test] public async Task DensePartialSortBy() { var ns = SuperEnumerable.RandomDouble().Take(10).ToArray(); @@ -24,9 +24,9 @@ await sorted.Select(e => e.Value).AssertSequenceEqual( ns.Take(3).SelectMany(x => new[] { x, x })); } - [Theory] - [InlineData(OrderByDirection.Ascending)] - [InlineData(OrderByDirection.Descending)] + [Test] + [Arguments(OrderByDirection.Ascending)] + [Arguments(OrderByDirection.Descending)] public async Task DensePartialSortWithOrder(OrderByDirection direction) { var ns = SuperEnumerable.RandomDouble() @@ -48,7 +48,7 @@ await sorted.Select(e => e.Value).AssertSequenceEqual( ns.Take(3).SelectMany(x => new[] { x, x })); } - [Fact] + [Test] public async Task DensePartialSortWithComparer() { var alphabet = Enumerable.Range(0, 26) @@ -65,7 +65,7 @@ await sorted.Select(e => e.Key[0]) .AssertSequenceEqual('A', 'A', 'C', 'C', 'E', 'E'); } - [Fact] + [Test] public async Task DensePartialSortByIsStable() { await using var list = new[] diff --git a/Tests/SuperLinq.Async.Test/DensePartialSortTest.cs b/Tests/SuperLinq.Async.Tests/DensePartialSortTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/DensePartialSortTest.cs rename to Tests/SuperLinq.Async.Tests/DensePartialSortTest.cs index 85f5d78a4..db74f1780 100644 --- a/Tests/SuperLinq.Async.Test/DensePartialSortTest.cs +++ b/Tests/SuperLinq.Async.Tests/DensePartialSortTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DensePartialSortTests { - [Fact] + [Test] public void DensePartialSortIsLazy() { _ = new AsyncBreakingSequence().DensePartialSort(1); } - [Fact] + [Test] public async Task DensePartialSort() { await using var xs = AsyncEnumerable.Range(1, 10) @@ -22,9 +22,9 @@ await xs .AssertSequenceEqual(0, 1, 1, 2, 2); } - [Theory] - [InlineData(OrderByDirection.Ascending)] - [InlineData(OrderByDirection.Descending)] + [Test] + [Arguments(OrderByDirection.Ascending)] + [Arguments(OrderByDirection.Descending)] public async Task DensePartialSortWithOrder(OrderByDirection direction) { await using var xs = AsyncEnumerable.Range(1, 10) @@ -40,7 +40,7 @@ public async Task DensePartialSortWithOrder(OrderByDirection direction) await sorted.AssertSequenceEqual(0, 1, 1, 2, 2); } - [Fact] + [Test] public async Task DensePartialSortWithComparer() { var alphabet = Enumerable.Range(0, 26) @@ -57,7 +57,7 @@ await xs .AssertSequenceEqual('A', 'A', 'C', 'C', 'E', 'E'); } - [Fact] + [Test] public async Task DensePartialSortIsStable() { await using var list = new[] diff --git a/Tests/SuperLinq.Async.Test/DenseRankTest.cs b/Tests/SuperLinq.Async.Tests/DenseRankTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/DenseRankTest.cs rename to Tests/SuperLinq.Async.Tests/DenseRankTest.cs index 679330c14..682380e80 100644 --- a/Tests/SuperLinq.Async.Test/DenseRankTest.cs +++ b/Tests/SuperLinq.Async.Tests/DenseRankTest.cs @@ -1,11 +1,11 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DenseRankTests { /// /// Verify that DenseRank uses deferred execution /// - [Fact] + [Test] public void TestDenseRankIsLazy() { _ = new AsyncBreakingSequence().DenseRank(); @@ -15,7 +15,7 @@ public void TestDenseRankIsLazy() /// /// Verify that DenseRankBy uses deferred execution /// - [Fact] + [Test] public void TestDenseRankByIsLazy() { _ = new AsyncBreakingSequence().DenseRankBy(BreakingFunc.Of()); @@ -26,7 +26,7 @@ public void TestDenseRankByIsLazy() /// Verify that calling DenseRank with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Fact] + [Test] public async Task TestRankNullComparer() { await using var sequence = @@ -49,7 +49,7 @@ await sequence /// Verify that calling DenseRankBy with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Fact] + [Test] public async Task TestRankByNullComparer() { await using var sequence = @@ -73,7 +73,7 @@ await sequence /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Fact] + [Test] public async Task TestRankDescendingSequence() { await using var sequence = @@ -102,7 +102,7 @@ public async Task TestRankDescendingSequence() /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Fact] + [Test] public async Task TestRankByAscendingSeries() { await using var sequence = @@ -130,7 +130,7 @@ public async Task TestRankByAscendingSeries() /// results in a sequence in descending order, using OrderByDirection.Descending /// with the default comparer for the given element. /// - [Fact] + [Test] public async Task TestRankOrderByDescending() { await using var sequence = @@ -152,7 +152,7 @@ await sequence /// /// Verify that the rank of equivalent items in a sequence is the same. /// - [Fact] + [Test] public async Task TestRankGroupedItems() { await using var sequence = @@ -185,7 +185,7 @@ public async Task TestRankGroupedItems() /// /// Verify that the highest rank (that of the largest item) is 1 (not 0). /// - [Fact] + [Test] public async Task TestRankOfHighestItemIsOne() { await using var sequence = @@ -207,7 +207,7 @@ public record Person(string Name, int Age, int ExpectedRank); /// /// Verify that we can rank items by an arbitrary key produced from the item. /// - [Fact] + [Test] public async Task TestRankByKeySelector() { var sequences = new List @@ -257,7 +257,7 @@ public async Task TestRankByKeySelector() /// /// Verify that Rank can use a custom comparer /// - [Fact] + [Test] public async Task TestRankCustomComparer() { var ordinals = Enumerable.Range(1, 10); diff --git a/Tests/SuperLinq.Async.Test/DistinctByTest.cs b/Tests/SuperLinq.Async.Tests/DistinctByTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/DistinctByTest.cs rename to Tests/SuperLinq.Async.Tests/DistinctByTest.cs index b35f3cedf..d8e45970e 100644 --- a/Tests/SuperLinq.Async.Test/DistinctByTest.cs +++ b/Tests/SuperLinq.Async.Tests/DistinctByTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DistinctByTest { - [Fact] + [Test] public async Task DistinctBy() { await using var source = TestingSequence.Of("first", "second", "third", "fourth", "fifth"); @@ -10,13 +10,13 @@ public async Task DistinctBy() await distinct.AssertSequenceEqual("first", "second"); } - [Fact] + [Test] public void DistinctByIsLazy() { _ = new AsyncBreakingSequence().DistinctBy(BreakingFunc.Of()); } - [Fact] + [Test] public async Task DistinctByWithComparer() { await using var source = TestingSequence.Of("first", "FIRST", "second", "second", "third"); @@ -24,7 +24,7 @@ public async Task DistinctByWithComparer() await distinct.AssertSequenceEqual("first", "second", "third"); } - [Fact] + [Test] public async Task DistinctByNullComparer() { await using var source = TestingSequence.Of("first", "second", "third", "fourth", "fifth"); @@ -32,7 +32,7 @@ public async Task DistinctByNullComparer() await distinct.AssertSequenceEqual("first", "second"); } - [Fact] + [Test] public void DistinctByIsLazyWithComparer() { _ = new AsyncBreakingSequence().DistinctBy(BreakingFunc.Of(), StringComparer.Ordinal); diff --git a/Tests/SuperLinq.Async.Test/DistinctUntilChangedTest.cs b/Tests/SuperLinq.Async.Tests/DistinctUntilChangedTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/DistinctUntilChangedTest.cs rename to Tests/SuperLinq.Async.Tests/DistinctUntilChangedTest.cs index 8013578e6..1345b9a46 100644 --- a/Tests/SuperLinq.Async.Test/DistinctUntilChangedTest.cs +++ b/Tests/SuperLinq.Async.Tests/DistinctUntilChangedTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DistinctUntilChangedTest { - [Fact] + [Test] public void DistinctUntilChangedIsLazy() { _ = new AsyncBreakingSequence().DistinctUntilChanged(); } - [Fact] + [Test] public async Task DistinctUntilChangedEmptySequence() { await using var source = TestingSequence.Of(); @@ -16,7 +16,7 @@ public async Task DistinctUntilChangedEmptySequence() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task DistinctUntilChanged() { await using var source = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 0, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -24,7 +24,7 @@ public async Task DistinctUntilChanged() await result.AssertSequenceEqual(2, 0, 5, 1, 0, 3, 0, 2, 3, 1, 4, 0, 2, 4, 3, 0); } - [Fact] + [Test] public async Task DistinctUntilChangedComparer() { await using var source = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 0, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -33,14 +33,14 @@ public async Task DistinctUntilChangedComparer() await result.AssertSequenceEqual(2, 0, 5, 1, 0, 2, 3, 1, 0, 2, 4, 3); } - [Fact] + [Test] public void DistinctUntilChangedSelectorIsLazy() { _ = new AsyncBreakingSequence().DistinctUntilChanged(BreakingFunc.Of()); _ = new AsyncBreakingSequence().DistinctUntilChanged(BreakingFunc.Of>()); } - [Fact] + [Test] public async Task DistinctUntilChangedSelectorEmptySequence() { await using var source = TestingSequence.Of(); @@ -48,7 +48,7 @@ public async Task DistinctUntilChangedSelectorEmptySequence() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task DistinctUntilChangedSelector() { await using var source = TestingSequence.Of( @@ -73,7 +73,7 @@ await result.AssertSequenceEqual( "ten"); } - [Fact] + [Test] public async Task DistinctUntilChangedSelectorComparer() { await using var source = TestingSequence.Of( diff --git a/Tests/SuperLinq.Async.Test/DoTest.cs b/Tests/SuperLinq.Async.Tests/DoTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/DoTest.cs rename to Tests/SuperLinq.Async.Tests/DoTest.cs index 9cb77f8c9..a521b23ee 100644 --- a/Tests/SuperLinq.Async.Test/DoTest.cs +++ b/Tests/SuperLinq.Async.Tests/DoTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DoTest { - [Fact] + [Test] public void DoOverloadsAreLazy() { _ = new AsyncBreakingSequence().Do(BreakingAction.Of()); @@ -10,7 +10,7 @@ public void DoOverloadsAreLazy() _ = new AsyncBreakingSequence().Do(BreakingAction.Of(), BreakingAction.Of(), BreakingAction.Of()); } - [Fact] + [Test] public async Task DoBehavior() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -22,7 +22,7 @@ public async Task DoBehavior() Assert.Equal(55, count); } - [Fact] + [Test] public async Task DoCompletedBehavior() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -34,7 +34,7 @@ public async Task DoCompletedBehavior() Assert.Equal(65, count); } - [Fact] + [Test] public async Task DoBehaviorNoError() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -46,7 +46,7 @@ public async Task DoBehaviorNoError() Assert.Equal(55, count); } - [Fact] + [Test] public async Task DoCompletedBehaviorNoError() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -58,7 +58,7 @@ public async Task DoCompletedBehaviorNoError() Assert.Equal(65, count); } - [Fact] + [Test] public async Task DoBehaviorError() { await using var seq = Enumerable.Range(1, 10) @@ -76,7 +76,7 @@ await seq Assert.Equal(155, count); } - [Fact] + [Test] public async Task DoCompletedBehaviorError() { await using var seq = Enumerable.Range(1, 10) diff --git a/Tests/SuperLinq.Async.Test/DoWhileTest.cs b/Tests/SuperLinq.Async.Tests/DoWhileTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/DoWhileTest.cs rename to Tests/SuperLinq.Async.Tests/DoWhileTest.cs index b3129c00a..b43098138 100644 --- a/Tests/SuperLinq.Async.Test/DoWhileTest.cs +++ b/Tests/SuperLinq.Async.Tests/DoWhileTest.cs @@ -1,15 +1,15 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class DoWhileTest { - [Fact] + [Test] public void DoWhileIsLazy() { _ = new AsyncBreakingSequence().DoWhile(BreakingFunc.Of()); _ = new AsyncBreakingSequence().DoWhile(BreakingFunc.Of>()); } - [Fact] + [Test] public async Task DoWhileBehavior() { await using var ts = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Tests/DuplicatesTest.cs b/Tests/SuperLinq.Async.Tests/DuplicatesTest.cs new file mode 100644 index 000000000..5289169db --- /dev/null +++ b/Tests/SuperLinq.Async.Tests/DuplicatesTest.cs @@ -0,0 +1,40 @@ +namespace SuperLinq.Async.Tests; + +public sealed class DuplicatesTest +{ + [Test] + public void DuplicatesIsLazy() + { + _ = new AsyncBreakingSequence().Duplicates(); + } + + [Test] + [Arguments(new int[] { 1, 2, 3 }, new int[] { })] + [Arguments(new int[] { 1, 2, 1, 3, 1, 2, 1 }, new int[] { 1, 2 })] + [Arguments(new int[] { 3, 3, 2, 2, 1, 1 }, new int[] { 3, 2, 1 })] + public async Task DuplicatesBehavior(IEnumerable source, IEnumerable expected) + { + await using var ts = source.AsTestingSequence(); + + var result = ts.Duplicates(); + await result.AssertSequenceEqual(expected); + } + + public static IEnumerable<(IEnumerable source, StringComparer comparer, IEnumerable expected)> GetStringParameters() => + [ + (["foo", "bar", "qux"], StringComparer.Ordinal, []), + (["foo", "FOO", "bar", "qux"], StringComparer.Ordinal, []), + (["foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, ["FOO"]), + (["Bar", "foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, ["FOO", "bar"]), + ]; + + [Test] + [MethodDataSource(nameof(GetStringParameters))] + public async Task DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, IEnumerable expected) + { + await using var ts = source.AsTestingSequence(); + + var result = ts.Duplicates(comparer); + await result.AssertSequenceEqual(expected); + } +} diff --git a/Tests/SuperLinq.Async.Test/ElementAtTest.cs b/Tests/SuperLinq.Async.Tests/ElementAtTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/ElementAtTest.cs rename to Tests/SuperLinq.Async.Tests/ElementAtTest.cs index d05d362fd..246d9a3f4 100644 --- a/Tests/SuperLinq.Async.Test/ElementAtTest.cs +++ b/Tests/SuperLinq.Async.Tests/ElementAtTest.cs @@ -3,11 +3,11 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ElementAtTest { - [Fact] + [Test] public async Task FromStartIndexInt() { var q = AsyncSeq(9999, 0, 888, -1, 66, -777, 1, 2, -12345); @@ -16,7 +16,7 @@ public async Task FromStartIndexInt() Assert.Equal(-1, await q.ElementAtOrDefaultAsync(new Index(3))); } - [Fact] + [Test] public async Task FromStartIndexOutOfRangeInt() { var q = AsyncSeq(9999, 0, 888, -1, 66, -777, 1, 2, -12345); @@ -26,7 +26,7 @@ public async Task FromStartIndexOutOfRangeInt() Assert.Equal(default, await q.ElementAtOrDefaultAsync(new Index(10))); } - [Fact] + [Test] public async Task FromEndIndexInt() { var q = AsyncSeq(9999, 0, 888, -1, 66, -777, 1, 2, -12345); @@ -35,7 +35,7 @@ public async Task FromEndIndexInt() Assert.Equal(888, await q.ElementAtOrDefaultAsync(^7)); } - [Fact] + [Test] public async Task FromEndIndexOutOfRangeInt() { var q = AsyncSeq(9999, 0, 888, -1, 66, -777, 1, 2, -12345); @@ -45,7 +45,7 @@ public async Task FromEndIndexOutOfRangeInt() Assert.Equal(default, await q.ElementAtOrDefaultAsync(^10)); } - [Fact] + [Test] public async Task FromStartIndexString() { var q = AsyncSeq("!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", ""); @@ -54,7 +54,7 @@ public async Task FromStartIndexString() Assert.Equal("", await q.ElementAtOrDefaultAsync(new Index(3))); } - [Fact] + [Test] public async Task FromStartIndexOutOfRangeString() { var q = AsyncSeq("!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", ""); @@ -64,7 +64,7 @@ public async Task FromStartIndexOutOfRangeString() Assert.Equal(default, await q.ElementAtOrDefaultAsync(new Index(10))); } - [Fact] + [Test] public async Task FromEndIndexString() { var q = AsyncSeq("!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", ""); @@ -73,7 +73,7 @@ public async Task FromEndIndexString() Assert.Equal("", await q.ElementAtOrDefaultAsync(^4)); } - [Fact] + [Test] public async Task FromEndIndexOutOfRangeString() { var q = AsyncSeq("!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", ""); diff --git a/Tests/SuperLinq.Async.Test/EndsWithTest.cs b/Tests/SuperLinq.Async.Tests/EndsWithTest.cs similarity index 74% rename from Tests/SuperLinq.Async.Test/EndsWithTest.cs rename to Tests/SuperLinq.Async.Tests/EndsWithTest.cs index 2f16686a8..82c8133fe 100644 --- a/Tests/SuperLinq.Async.Test/EndsWithTest.cs +++ b/Tests/SuperLinq.Async.Tests/EndsWithTest.cs @@ -1,21 +1,21 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class EndsWithTest { - [Theory] - [InlineData(new[] { 1, 2, 3 }, new[] { 2, 3 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 0, 1, 2, 3 }, false)] + [Test] + [Arguments(new[] { 1, 2, 3 }, new[] { 2, 3 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 0, 1, 2, 3 }, false)] public async Task EndsWithWithIntegers(IEnumerable first, IEnumerable second, bool expected) { await using var f = first.AsTestingSequence(); Assert.Equal(expected, await f.EndsWith(second)); } - [Theory] - [InlineData(new[] { '1', '2', '3' }, new[] { '2', '3' }, true)] - [InlineData(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, true)] - [InlineData(new[] { '1', '2', '3' }, new[] { '0', '1', '2', '3' }, false)] + [Test] + [Arguments(new[] { '1', '2', '3' }, new[] { '2', '3' }, true)] + [Arguments(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, true)] + [Arguments(new[] { '1', '2', '3' }, new[] { '0', '1', '2', '3' }, false)] public async Task EndsWithWithChars(IEnumerable first, IEnumerable second, bool expected) { await using var f = first.AsTestingSequence(); @@ -23,10 +23,10 @@ public async Task EndsWithWithChars(IEnumerable first, IEnumerable s Assert.Equal(expected, await f.EndsWith(s)); } - [Theory] - [InlineData("123", "23", true)] - [InlineData("123", "123", true)] - [InlineData("123", "0123", false)] + [Test] + [Arguments("123", "23", true)] + [Arguments("123", "123", true)] + [Arguments("123", "0123", false)] public async Task EndsWithWithStrings(string first, string second, bool expected) { await using var f = first.AsTestingSequence(); @@ -34,7 +34,7 @@ public async Task EndsWithWithStrings(string first, string second, bool expected Assert.Equal(expected, await f.EndsWith(s)); } - [Fact] + [Test] public async Task EndsWithReturnsTrueIfBothEmpty() { await using var f = TestingSequence.Of(); @@ -42,7 +42,7 @@ public async Task EndsWithReturnsTrueIfBothEmpty() Assert.True(await f.EndsWith(s)); } - [Fact] + [Test] public async Task EndsWithReturnsFalseIfOnlyFirstIsEmpty() { await using var f = TestingSequence.Of(); @@ -50,9 +50,9 @@ public async Task EndsWithReturnsFalseIfOnlyFirstIsEmpty() Assert.False(await f.EndsWith(s)); } - [Theory] - [InlineData("", "", true)] - [InlineData("1", "", true)] + [Test] + [Arguments("", "", true)] + [Arguments("1", "", true)] public async Task EndsWithReturnsTrueIfSecondIsEmpty(string first, string second, bool expected) { await using var f = first.AsTestingSequence(); @@ -60,7 +60,7 @@ public async Task EndsWithReturnsTrueIfSecondIsEmpty(string first, string second Assert.Equal(expected, await f.EndsWith(s)); } - [Fact] + [Test] public async Task EndsWithUsesSpecifiedEqualityComparerOrDefault() { var first = AsyncSeq(1, 2, 3); diff --git a/Tests/SuperLinq.Async.Test/EquiZipTest.cs b/Tests/SuperLinq.Async.Tests/EquiZipTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/EquiZipTest.cs rename to Tests/SuperLinq.Async.Tests/EquiZipTest.cs index 84979d8d1..83211ca7e 100644 --- a/Tests/SuperLinq.Async.Test/EquiZipTest.cs +++ b/Tests/SuperLinq.Async.Tests/EquiZipTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class EquiZipTest { - [Fact] + [Test] public void EquiZipIsLazy() { var bs = new AsyncBreakingSequence(); @@ -11,7 +11,7 @@ public void EquiZipIsLazy() _ = bs.EquiZip(bs, bs, bs, BreakingFunc.Of()); } - [Fact] + [Test] public async Task MoveNextIsNotCalledUnnecessarily3() { await using var s1 = TestingSequence.Of(1, 2); @@ -28,7 +28,7 @@ public async Task MoveNextIsNotCalledUnnecessarily3() await s1.EquiZip(s2, s3).Consume()); } - [Fact] + [Test] public async Task MoveNextIsNotCalledUnnecessarily4() { await using var s1 = TestingSequence.Of(1, 2); @@ -46,7 +46,7 @@ public async Task MoveNextIsNotCalledUnnecessarily4() await s1.EquiZip(s2, s3, s4).Consume()); } - [Fact] + [Test] public async Task TwoParamsWorksCorrectly() { await using var seq1 = Enumerable.Range(1, 3).AsTestingSequence(); @@ -57,9 +57,9 @@ await seq1.EquiZip(seq2) Enumerable.Range(1, 3).Select(x => (x, x))); } - [Theory] - [InlineData(1, "First")] - [InlineData(2, "Second")] + [Test] + [Arguments(1, "First")] + [Arguments(2, "Second")] public async Task TwoParamsThrowsOnCorrectSequence(int shortSequence, string cardinal) { await using var seq1 = Enumerable.Range(1, shortSequence == 1 ? 2 : 3).AsTestingSequence(); @@ -70,7 +70,7 @@ public async Task TwoParamsThrowsOnCorrectSequence(int shortSequence, string car Assert.Equal($"{cardinal} sequence too short.", ex.Message); } - [Fact] + [Test] public async Task ThreeParamsWorksCorrectly() { await using var seq1 = Enumerable.Range(1, 3).AsTestingSequence(); @@ -82,10 +82,10 @@ await seq1.EquiZip(seq2, seq3) Enumerable.Range(1, 3).Select(x => (x, x, x))); } - [Theory] - [InlineData(1, "First")] - [InlineData(2, "Second")] - [InlineData(3, "Third")] + [Test] + [Arguments(1, "First")] + [Arguments(2, "Second")] + [Arguments(3, "Third")] public async Task ThreeParamsThrowsOnCorrectSequence(int shortSequence, string cardinal) { await using var seq1 = Enumerable.Range(1, shortSequence == 1 ? 2 : 3).AsTestingSequence(); @@ -97,7 +97,7 @@ public async Task ThreeParamsThrowsOnCorrectSequence(int shortSequence, string c Assert.Equal($"{cardinal} sequence too short.", ex.Message); } - [Fact] + [Test] public async Task FourParamsWorksCorrectly() { await using var seq1 = Enumerable.Range(1, 3).AsTestingSequence(); @@ -110,11 +110,11 @@ await seq1.EquiZip(seq2, seq3, seq4) Enumerable.Range(1, 3).Select(x => (x, x, x, x))); } - [Theory] - [InlineData(1, "First")] - [InlineData(2, "Second")] - [InlineData(3, "Third")] - [InlineData(4, "Fourth")] + [Test] + [Arguments(1, "First")] + [Arguments(2, "Second")] + [Arguments(3, "Third")] + [Arguments(4, "Fourth")] public async Task FourParamsThrowsOnCorrectSequence(int shortSequence, string cardinal) { await using var seq1 = Enumerable.Range(1, shortSequence == 1 ? 2 : 3).AsTestingSequence(); @@ -127,7 +127,7 @@ public async Task FourParamsThrowsOnCorrectSequence(int shortSequence, string ca Assert.Equal($"{cardinal} sequence too short.", ex.Message); } - [Fact] + [Test] public async Task ZipDisposesInnerSequencesCaseGetEnumeratorThrows() { await using var s1 = TestingSequence.Of(1, 2); diff --git a/Tests/SuperLinq.Async.Test/ExactlyTest.cs b/Tests/SuperLinq.Async.Tests/ExactlyTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/ExactlyTest.cs rename to Tests/SuperLinq.Async.Tests/ExactlyTest.cs index 60a847229..fd5cd7e90 100644 --- a/Tests/SuperLinq.Async.Test/ExactlyTest.cs +++ b/Tests/SuperLinq.Async.Tests/ExactlyTest.cs @@ -1,43 +1,43 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ExactlyTest { - [Fact] + [Test] public async Task ExactlyWithNegativeCount() { _ = await Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().Exactly(-1)); } - [Fact] + [Test] public async Task ExactlyWithEmptySequenceHasExactlyZeroElements() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.True(await xs.Exactly(0)); } - [Fact] + [Test] public async Task ExactlyWithEmptySequenceHasExactlyOneElement() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); Assert.False(await xs.Exactly(1)); } - [Fact] + [Test] public async Task ExactlyWithSingleElementHasExactlyOneElements() { await using var xs = TestingSequence.Of(1); Assert.True(await xs.Exactly(1)); } - [Fact] + [Test] public async Task ExactlyWithManyElementHasExactlyOneElement() { await using var xs = TestingSequence.Of(1, 2, 3); Assert.False(await xs.Exactly(1)); } - [Fact] + [Test] public async Task ExactlyDoesNotIterateUnnecessaryElements() { await using var xs = AsyncSeqExceptionAt(4).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ExceptByTest.cs b/Tests/SuperLinq.Async.Tests/ExceptByTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/ExceptByTest.cs rename to Tests/SuperLinq.Async.Tests/ExceptByTest.cs index 9c4fb7d3e..ca246ff43 100644 --- a/Tests/SuperLinq.Async.Test/ExceptByTest.cs +++ b/Tests/SuperLinq.Async.Tests/ExceptByTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ExceptByTest { - [Fact] + [Test] public async Task SimpleExceptBy() { await using var first = TestingSequence.Of("aaa", "bb", "c", "dddd"); @@ -11,14 +11,14 @@ public async Task SimpleExceptBy() await result.AssertSequenceEqual("aaa", "dddd"); } - [Fact] + [Test] public void ExceptByIsLazy() { var bs = new AsyncBreakingSequence(); _ = bs.ExceptBy(bs, BreakingFunc.Of()); } - [Fact] + [Test] public async Task ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() { await using var first = TestingSequence.Of("aaa", "bb", "c", "a", "b", "c", "dddd"); @@ -27,7 +27,7 @@ public async Task ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() await result.AssertSequenceEqual("aaa", "c", "dddd"); } - [Fact] + [Test] public async Task ExceptByWithComparer() { await using var first = TestingSequence.Of("first", "second", "third", "fourth"); @@ -36,7 +36,7 @@ public async Task ExceptByWithComparer() await result.AssertSequenceEqual("second", "fourth"); } - [Fact] + [Test] public async Task ExceptByNullComparer() { await using var first = TestingSequence.Of("aaa", "bb", "c", "dddd"); @@ -45,7 +45,7 @@ public async Task ExceptByNullComparer() await result.AssertSequenceEqual("aaa", "dddd"); } - [Fact] + [Test] public void ExceptByIsLazyWithComparer() { var bs = new AsyncBreakingSequence(); diff --git a/Tests/SuperLinq.Async.Test/FallbackIfEmptyTest.cs b/Tests/SuperLinq.Async.Tests/FallbackIfEmptyTest.cs similarity index 91% rename from Tests/SuperLinq.Async.Test/FallbackIfEmptyTest.cs rename to Tests/SuperLinq.Async.Tests/FallbackIfEmptyTest.cs index a3a59d403..9a2776ee0 100644 --- a/Tests/SuperLinq.Async.Test/FallbackIfEmptyTest.cs +++ b/Tests/SuperLinq.Async.Tests/FallbackIfEmptyTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FallbackIfEmptyTest { - [Fact] + [Test] public async Task FallbackIfEmptyWithEmptySequence() { await using var source = AsyncEnumerable.Empty().AsTestingSequence(maxEnumerations: 2); @@ -10,7 +10,7 @@ public async Task FallbackIfEmptyWithEmptySequence() await source.FallbackIfEmpty(12, 23).AssertSequenceEqual(12, 23); } - [Fact] + [Test] public async Task FallbackIfEmptyWithNotEmptySequence() { await using var source = AsyncSeq(1).AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Async.Test/FillBackwardTest.cs b/Tests/SuperLinq.Async.Tests/FillBackwardTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/FillBackwardTest.cs rename to Tests/SuperLinq.Async.Tests/FillBackwardTest.cs index ca89eee43..6c03e7f26 100644 --- a/Tests/SuperLinq.Async.Test/FillBackwardTest.cs +++ b/Tests/SuperLinq.Async.Tests/FillBackwardTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FillBackwardTest { - [Fact] + [Test] public void FillBackwardIsLazy() { _ = new AsyncBreakingSequence().FillBackward(); } - [Fact] + [Test] public async Task FillBackward() { await using var input = TestingSequence.Of(null, null, 1, 2, null, null, null, 3, 4, null, null); @@ -18,7 +18,7 @@ await input .AssertSequenceEqual(1, 1, 1, 2, 3, 3, 3, 3, 4, null, null); } - [Fact] + [Test] public async Task FillBackwardWithFillSelector() { await using var xs = AsyncSeq(0, 0, 1, 2, 0, 0, 0, 3, 4, 0, 0) diff --git a/Tests/SuperLinq.Async.Test/FillForwardTest.cs b/Tests/SuperLinq.Async.Tests/FillForwardTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/FillForwardTest.cs rename to Tests/SuperLinq.Async.Tests/FillForwardTest.cs index 072a1cf46..d24190e4d 100644 --- a/Tests/SuperLinq.Async.Test/FillForwardTest.cs +++ b/Tests/SuperLinq.Async.Tests/FillForwardTest.cs @@ -1,16 +1,16 @@ using System.Globalization; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FillForwardTest { - [Fact] + [Test] public void FillForwardIsLazy() { _ = new AsyncBreakingSequence().FillForward(); } - [Fact] + [Test] public async Task FillForward() { await using var input = TestingSequence.Of(null, null, 1, 2, null, null, null, 3, 4, null, null); @@ -20,7 +20,7 @@ await input .AssertSequenceEqual(default, null, 1, 2, 2, 2, 2, 3, 4, 4, 4); } - [Fact] + [Test] public async Task FillForwardWithFillSelector() { const string Table = @" diff --git a/Tests/SuperLinq.Async.Test/FinallyTest.cs b/Tests/SuperLinq.Async.Tests/FinallyTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/FinallyTest.cs rename to Tests/SuperLinq.Async.Tests/FinallyTest.cs index 1881f1122..5f923e7ad 100644 --- a/Tests/SuperLinq.Async.Test/FinallyTest.cs +++ b/Tests/SuperLinq.Async.Tests/FinallyTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FinallyTest { - [Fact] + [Test] public void FinallyIsLazy() { _ = new AsyncBreakingSequence().Finally(BreakingAction.Of()); } - [Fact] + [Test] public async Task FinallyExecutesOnCompletion() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -21,7 +21,7 @@ public async Task FinallyExecutesOnCompletion() Assert.True(ran); } - [Fact] + [Test] public async Task FinallyExecutesOnException() { await using var seq = AsyncSeqExceptionAt(4).AsTestingSequence(); @@ -39,7 +39,7 @@ public async Task FinallyExecutesOnException() Assert.True(ran); } - [Fact] + [Test] public async Task FinallyExecutesOnTake() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -54,7 +54,7 @@ await result Assert.True(ran); } - [Fact] + [Test] public async Task FinallyExecutesOnEarlyDisposal() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/FindIndexTest.cs b/Tests/SuperLinq.Async.Tests/FindIndexTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/FindIndexTest.cs rename to Tests/SuperLinq.Async.Tests/FindIndexTest.cs index 2b80c4779..9e4025acd 100644 --- a/Tests/SuperLinq.Async.Test/FindIndexTest.cs +++ b/Tests/SuperLinq.Async.Tests/FindIndexTest.cs @@ -1,24 +1,24 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FindIndexTest { - [Fact] + [Test] public async Task FindIndexWithNegativeCount() { _ = await Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().FindIndex(BreakingFunc.Of(), 1, -1)); } - [Fact] + [Test] public async Task FindIndexWorksWithEmptySequence() { await using var sequence = TestingSequence.Of(); Assert.Equal(-1, await sequence.FindIndex(BreakingFunc.Of())); } - [Fact] + [Test] public async Task FindIndexFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -27,7 +27,7 @@ public async Task FindIndexFromStart() await sequence.FindIndex(i => i == 102)); } - [Fact] + [Test] public async Task FindIndexFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -36,7 +36,7 @@ public async Task FindIndexFromStartCount() await sequence.FindIndex(i => i == 102, 0, 3)); } - [Fact] + [Test] public async Task FindIndexFromStartIndex() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -47,7 +47,7 @@ public async Task FindIndexFromStartIndex() await sequence.FindIndex(i => i == 102, 5)); } - [Fact] + [Test] public async Task FindIndexFromEndIndex() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -58,7 +58,7 @@ public async Task FindIndexFromEndIndex() await sequence.FindIndex(i => i == 102, ^5)); } - [Fact] + [Test] public async Task FindIndexMissingValueFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -67,7 +67,7 @@ public async Task FindIndexMissingValueFromStart() await sequence.FindIndex(i => i == 95)); } - [Fact] + [Test] public async Task FindIndexMissingValueFromEnd() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -76,7 +76,7 @@ public async Task FindIndexMissingValueFromEnd() await sequence.FindIndex(i => i == 95, ^5)); } - [Fact] + [Test] public async Task FindIndexMissingValueFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -85,7 +85,7 @@ public async Task FindIndexMissingValueFromStartCount() await sequence.FindIndex(i => i == 104, 0, 4)); } - [Fact] + [Test] public async Task FindIndexMissingValueFromEndCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -94,7 +94,7 @@ public async Task FindIndexMissingValueFromEndCount() await sequence.FindIndex(i => i == 104, ^5, 4)); } - [Fact] + [Test] public async Task FindIndexDoesNotIterateUnnecessaryElements() { using var source = AsyncSuperEnumerable @@ -112,7 +112,7 @@ public async Task FindIndexDoesNotIterateUnnecessaryElements() Assert.Equal(4, await source.FindIndex(i => i == "davi")); } - [Fact] + [Test] public async Task FindIndexDoesNotIterateUnnecessaryElementsCount() { using var source = AsyncSuperEnumerable diff --git a/Tests/SuperLinq.Async.Test/FindLastIndexTest.cs b/Tests/SuperLinq.Async.Tests/FindLastIndexTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/FindLastIndexTest.cs rename to Tests/SuperLinq.Async.Tests/FindLastIndexTest.cs index ff7f37830..499c6ec76 100644 --- a/Tests/SuperLinq.Async.Test/FindLastIndexTest.cs +++ b/Tests/SuperLinq.Async.Tests/FindLastIndexTest.cs @@ -1,24 +1,24 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FindLastIndexTest { - [Fact] + [Test] public async Task FindLastIndexWithNegativeCount() { _ = await Assert.ThrowsAsync(async () => await new AsyncBreakingSequence().FindLastIndex(i => i == 1, 1, -1)); } - [Fact] + [Test] public async Task FindLastIndexWorksWithEmptySequence() { await using var sequence = TestingSequence.Of(); Assert.Equal(-1, await sequence.FindLastIndex(i => i == 5)); } - [Fact] + [Test] public async Task FindLastIndexFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -29,7 +29,7 @@ public async Task FindLastIndexFromStart() await sequence.FindLastIndex(i => i == 102)); } - [Fact] + [Test] public async Task FindLastIndexFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -40,7 +40,7 @@ public async Task FindLastIndexFromStartCount() await sequence.FindLastIndex(i => i == 102, int.MaxValue, 8)); } - [Fact] + [Test] public async Task FindLastIndexFromStartIndex() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -51,7 +51,7 @@ public async Task FindLastIndexFromStartIndex() await sequence.FindLastIndex(i => i == 102, 8)); } - [Fact] + [Test] public async Task FindLastIndexFromEndIndex() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -62,7 +62,7 @@ public async Task FindLastIndexFromEndIndex() await sequence.FindLastIndex(i => i == 102, ^3)); } - [Fact] + [Test] public async Task FindLastIndexMissingValueFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -71,7 +71,7 @@ public async Task FindLastIndexMissingValueFromStart() await sequence.FindLastIndex(i => i == 95)); } - [Fact] + [Test] public async Task FindLastIndexMissingValueFromEnd() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -80,7 +80,7 @@ public async Task FindLastIndexMissingValueFromEnd() await sequence.FindLastIndex(i => i == 95, ^5)); } - [Fact] + [Test] public async Task FindLastIndexMissingValueFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -89,7 +89,7 @@ public async Task FindLastIndexMissingValueFromStartCount() await sequence.FindLastIndex(i => i == 100, int.MaxValue, 4)); } - [Fact] + [Test] public async Task FindLastIndexMissingValueFromEndCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/FoldTest.cs b/Tests/SuperLinq.Async.Tests/FoldTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/FoldTest.cs rename to Tests/SuperLinq.Async.Tests/FoldTest.cs index 81454ffc7..1b2ff4ed2 100644 --- a/Tests/SuperLinq.Async.Test/FoldTest.cs +++ b/Tests/SuperLinq.Async.Tests/FoldTest.cs @@ -1,29 +1,29 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FoldTest { - [Fact] + [Test] public async Task FoldWithTooFewItems() { _ = await Assert.ThrowsAsync(async () => await AsyncEnumerable.Range(1, 3).Fold(AsyncBreakingFunc.Of())); } - [Fact] + [Test] public async Task FoldWithEmptySequence() { _ = await Assert.ThrowsAsync(async () => await AsyncEnumerable.Empty().Fold(AsyncBreakingFunc.Of())); } - [Fact] + [Test] public async Task FoldWithTooManyItems() { _ = await Assert.ThrowsAsync(async () => await AsyncEnumerable.Range(1, 3).Fold(AsyncBreakingFunc.Of())); } - [Fact] + [Test] public async Task Fold() { const string Alphabet = "abcdefghijklmnopqrstuvwxyz"; diff --git a/Tests/SuperLinq.Async.Test/ForEachTest.cs b/Tests/SuperLinq.Async.Tests/ForEachTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/ForEachTest.cs rename to Tests/SuperLinq.Async.Tests/ForEachTest.cs index 019457345..17235495f 100644 --- a/Tests/SuperLinq.Async.Test/ForEachTest.cs +++ b/Tests/SuperLinq.Async.Tests/ForEachTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ForEachTest { - [Fact] + [Test] public async Task ForEachWithSequence() { await using var seq = TestingSequence.Of(1, 2, 3); @@ -13,7 +13,7 @@ public async Task ForEachWithSequence() results.AssertSequenceEqual(1, 2, 3); } - [Fact] + [Test] public async Task ForEachAsyncWithSequence() { await using var seq = TestingSequence.Of(1, 2, 3); @@ -24,7 +24,7 @@ public async Task ForEachAsyncWithSequence() results.AssertSequenceEqual(1, 2, 3); } - [Fact] + [Test] public async Task ForEachIndexedWithSequence() { await using var seq = TestingSequence.Of(9, 8, 7); @@ -37,7 +37,7 @@ public async Task ForEachIndexedWithSequence() indexResults.AssertSequenceEqual(0, 1, 2); } - [Fact] + [Test] public async Task ForEachIndexedAsyncWithSequence() { await using var seq = TestingSequence.Of(9, 8, 7); diff --git a/Tests/SuperLinq.Async.Test/FromTest.cs b/Tests/SuperLinq.Async.Tests/FromTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/FromTest.cs rename to Tests/SuperLinq.Async.Tests/FromTest.cs index d62b509a5..1d14bd9eb 100644 --- a/Tests/SuperLinq.Async.Test/FromTest.cs +++ b/Tests/SuperLinq.Async.Tests/FromTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class FromTest { - [Fact] + [Test] public void TestFromIsLazy() { var breakingFunc = AsyncBreakingFunc.Of(); @@ -12,11 +12,11 @@ public void TestFromIsLazy() _ = AsyncSuperEnumerable.From(breakingFunc, breakingFunc, breakingFunc, breakingFunc); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] public async Task TestFromInvokesMethods(int numArgs) { static Task F1() => Task.FromResult(-2); @@ -47,11 +47,11 @@ await AsyncSuperEnumerable.From(F1, F2, F3, F4) } } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] public async Task TestFromInvokesMethodsMultipleTimes(int numArgs) { var evals = new[] { 0, 0, 0, 0 }; diff --git a/Tests/SuperLinq.Async.Test/FullOuterJoinTest.cs b/Tests/SuperLinq.Async.Tests/FullOuterJoinTest.cs similarity index 85% rename from Tests/SuperLinq.Async.Test/FullOuterJoinTest.cs rename to Tests/SuperLinq.Async.Tests/FullOuterJoinTest.cs index c6cf9eb6c..5a68a1aea 100644 --- a/Tests/SuperLinq.Async.Test/FullOuterJoinTest.cs +++ b/Tests/SuperLinq.Async.Tests/FullOuterJoinTest.cs @@ -1,6 +1,6 @@ -using static Test.Async.JoinOperation; +using static SuperLinq.Async.Tests.JoinOperation; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public enum JoinOperation { None, Loop, Hash, Merge } @@ -10,7 +10,8 @@ public sealed class FullOuterJoinTest IAsyncEnumerable<(string, string)> left, IAsyncEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Hash, false) => left.FullOuterHashJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -21,10 +22,11 @@ public sealed class FullOuterJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetFullOuterJoins() => - new[] { Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetFullOuterJoins() => + new[] { Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public void FullOuterJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new AsyncBreakingSequence<(string, string)>(); @@ -33,7 +35,8 @@ public void FullOuterJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public async Task FullOuterJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -59,7 +62,8 @@ await result.AssertCollectionEqual( (default, quux)); } - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public async Task FullOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -76,7 +80,8 @@ await result.AssertCollectionEqual( (default, baz)); } - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public async Task FullOuterJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Async.Test/Future.cs b/Tests/SuperLinq.Async.Tests/Future.cs similarity index 88% rename from Tests/SuperLinq.Async.Test/Future.cs rename to Tests/SuperLinq.Async.Tests/Future.cs index 92c3ba8d2..3a141e1b4 100644 --- a/Tests/SuperLinq.Async.Test/Future.cs +++ b/Tests/SuperLinq.Async.Tests/Future.cs @@ -1,6 +1,6 @@ #if !NETCOREAPP -namespace Test.Async; +namespace SuperLinq.Async.Tests; public static class Future { diff --git a/Tests/SuperLinq.Async.Test/GenerateTest.cs b/Tests/SuperLinq.Async.Tests/GenerateTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/GenerateTest.cs rename to Tests/SuperLinq.Async.Tests/GenerateTest.cs index 715f3741e..37908a8f7 100644 --- a/Tests/SuperLinq.Async.Test/GenerateTest.cs +++ b/Tests/SuperLinq.Async.Tests/GenerateTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class GenerateTest { - [Fact] + [Test] public Task GenerateTerminatesWhenCheckReturnsFalse() { var result = AsyncSuperEnumerable.Generate(1, n => new ValueTask(n + 2)).TakeWhile(n => n < 10); @@ -10,7 +10,7 @@ public Task GenerateTerminatesWhenCheckReturnsFalse() return result.AssertSequenceEqual(1, 3, 5, 7, 9); } - [Fact] + [Test] public Task GenerateProcessesNonNumerics() { var result = AsyncSuperEnumerable.Generate("", s => new ValueTask(s + 'a')).TakeWhile(s => s.Length < 5); @@ -18,13 +18,13 @@ public Task GenerateProcessesNonNumerics() return result.AssertSequenceEqual("", "a", "aa", "aaa", "aaaa"); } - [Fact] + [Test] public void GenerateIsLazy() { _ = AsyncSuperEnumerable.Generate(0, async i => await AsyncBreakingFunc.Of()(i)); } - [Fact] + [Test] public async Task GenerateFuncIsNotInvokedUnnecessarily() { await AsyncSuperEnumerable.Generate(0, async i => await AsyncBreakingFunc.Of()(i)) diff --git a/Tests/SuperLinq.Async.Test/GetShortestPathTest.cs b/Tests/SuperLinq.Async.Tests/GetShortestPathTest.cs similarity index 81% rename from Tests/SuperLinq.Async.Test/GetShortestPathTest.cs rename to Tests/SuperLinq.Async.Tests/GetShortestPathTest.cs index e73029882..6a55cd1b0 100644 --- a/Tests/SuperLinq.Async.Test/GetShortestPathTest.cs +++ b/Tests/SuperLinq.Async.Tests/GetShortestPathTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public static class GetShortestPathTest { @@ -44,21 +44,27 @@ private static void VerifySequences(this List> list) public sealed class Dijkstra { - public static IEnumerable GetStringIntCostData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + int expectedCost, + int expectedCount + )> GetStringIntCostData() => [ - [null, null, 15, 7,], - [StringComparer.InvariantCultureIgnoreCase, null, 10, 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1,], + (null, null, 15, 7), + (StringComparer.InvariantCultureIgnoreCase, null, 10, 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1), ]; - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public async Task GetStringIntCostByState( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -82,13 +88,14 @@ public async Task GetStringIntCostByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public async Task GetStringIntCostByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -114,21 +121,27 @@ public async Task GetStringIntCostByFunction( sequences.VerifySequences(); } - public static IEnumerable GetStringIntPathData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + IEnumerable<(string state, int cost)> expectedPath, + int expectedCount + )> GetStringIntPathData() => [ - [null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7,], - [StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1,], + (null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7), + (StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1), ]; - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public async Task GetStringIntPathByState( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -154,13 +167,14 @@ public async Task GetStringIntPathByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public async Task GetStringIntPathByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -184,12 +198,16 @@ public async Task GetStringIntPathByFunction( sequences.VerifySequences(); } - public static IEnumerable GetStringIntPathsData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + IEnumerable<(string state, (string? prevState, int cost))> expectedMap + )> GetStringIntPathsData() => [ - [ + ( null, null, - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 1)), ("b", ("a", 3)), @@ -200,23 +218,25 @@ public async Task GetStringIntPathByFunction( ("B", ("A", 30)), ("C", ("B", 60)), ("D", ("C", 100)), - ("END", ("start", 10))), - ], - [ + ("END", ("start", 10)), + ] + ), + ( StringComparer.InvariantCultureIgnoreCase, null, - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 1)), ("b", ("a", 3)), ("c", ("b", 6)), ("d", ("c", 10)), - ("end", ("start", 10))), - ], - [ + ("end", ("start", 10)), + ] + ), + ( null, Comparer.Create((x, y) => -x.CompareTo(y)), - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 1)), ("b", ("a", 3)), @@ -227,27 +247,30 @@ public async Task GetStringIntPathByFunction( ("C", ("B", 60)), ("D", ("C", 100)), ("end", ("D", 150)), - ("END", ("start", 1000))), - ], - [ + ("END", ("start", 1000)), + ] + ), + ( StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 10)), ("b", ("a", 30)), ("c", ("b", 60)), ("d", ("c", 100)), - ("end", ("start", 1000))), - ], + ("end", ("start", 1000)), + ] + ), ]; - [Theory] - [MemberData(nameof(GetStringIntPathsData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathsData))] public async Task GetStringIntPaths( IEqualityComparer? stateComparer, IComparer? costComparer, - IEnumerable<(string state, (string? prevState, int cost))> expectedMap) + IEnumerable<(string state, (string? prevState, int cost))> expectedMap + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -278,7 +301,7 @@ public async Task GetStringIntPaths( sequences.VerifySequences(); } - [Fact] + [Test] public async Task GetRegularMapCost() { var count = 0; @@ -304,7 +327,7 @@ public async Task GetRegularMapCost() sequences.VerifySequences(); } - [Fact] + [Test] public async Task GetRegularMapPath() { var count = 0; @@ -337,7 +360,7 @@ public async Task GetRegularMapPath() sequences.VerifySequences(); } - [Fact] + [Test] public async Task InvalidMapThrowsException() { _ = await Assert.ThrowsAsync(async () => @@ -349,24 +372,30 @@ public async Task InvalidMapThrowsException() public sealed class AStar { - public static IEnumerable GetStringIntCostData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + int expectedCost, + int expectedCount + )> GetStringIntCostData() => [ - [null, null, 15, 7,], - [StringComparer.InvariantCultureIgnoreCase, null, 10, 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1,], + (null, null, 15, 7), + (StringComparer.InvariantCultureIgnoreCase, null, 10, 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1), ]; // No heuristic means this operates the same as Dijkstra; this is // to prove the base algorithm still works. // Primary improvement of A* is the heuristic to reduce nodes visited. - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public async Task GetStringIntCostByState( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -390,13 +419,14 @@ public async Task GetStringIntCostByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public async Task GetStringIntCostByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -422,24 +452,30 @@ public async Task GetStringIntCostByFunction( sequences.VerifySequences(); } - public static IEnumerable GetStringIntPathData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + IEnumerable<(string state, int cost)> expectedPath, + int expectedCount + )> GetStringIntPathData() => [ - [null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7,], - [StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1,], + (null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7), + (StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1), ]; // No heuristic means this operates the same as Dijkstra; this is // to prove the base algorithm still works. // Primary improvement of A* is the heuristic to reduce nodes visited. - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public async Task GetStringIntPathByState( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -463,13 +499,14 @@ public async Task GetStringIntPathByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public async Task GetStringIntPathByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -495,7 +532,7 @@ public async Task GetStringIntPathByFunction( sequences.VerifySequences(); } - [Fact] + [Test] public async Task GetRegularMapCost() { var start = (x: 0, y: 0); @@ -531,7 +568,7 @@ public async Task GetRegularMapCost() sequences.VerifySequences(); } - [Fact] + [Test] public async Task GetRegularMapPath() { var start = (x: 0, y: 0); @@ -573,7 +610,7 @@ public async Task GetRegularMapPath() sequences.VerifySequences(); } - [Fact] + [Test] public async Task InvalidMapThrowsException() { _ = await Assert.ThrowsAsync(async () => diff --git a/Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs b/Tests/SuperLinq.Async.Tests/GroupAdjacentTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs rename to Tests/SuperLinq.Async.Tests/GroupAdjacentTest.cs index 71fa0074b..02f5f6443 100644 --- a/Tests/SuperLinq.Async.Test/GroupAdjacentTest.cs +++ b/Tests/SuperLinq.Async.Tests/GroupAdjacentTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class GroupAdjacentTest { - [Fact] + [Test] public void GroupAdjacentIsLazy() { var bs = new AsyncBreakingSequence(); @@ -18,7 +18,7 @@ public void GroupAdjacentIsLazy() _ = bs.GroupAdjacent(bf, bfg, EqualityComparer.Default); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequence() { const string One = "one"; @@ -47,7 +47,7 @@ public async Task GroupAdjacentSourceSequence() await reader.ReadEnd(); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequenceComparer() { await using var source = TestingSequence.Of("foo", "FOO", "Foo", "bar", "BAR", "Bar"); @@ -60,7 +60,7 @@ public async Task GroupAdjacentSourceSequenceComparer() await reader.ReadEnd(); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequenceElementSelector() { await using var source = TestingSequence.Of( @@ -87,7 +87,7 @@ public async Task GroupAdjacentSourceSequenceElementSelector() await reader.ReadEnd(); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequenceElementSelectorComparer() { await using var source = TestingSequence.Of( @@ -114,7 +114,7 @@ public async Task GroupAdjacentSourceSequenceElementSelectorComparer() await reader.ReadEnd(); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequenceResultSelector() { await using var source = TestingSequence.Of( @@ -141,7 +141,7 @@ public async Task GroupAdjacentSourceSequenceResultSelector() await reader.ReadEnd(); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequenceResultSelectorComparer() { await using var source = TestingSequence.Of( @@ -168,7 +168,7 @@ public async Task GroupAdjacentSourceSequenceResultSelectorComparer() await reader.ReadEnd(); } - [Fact] + [Test] public async Task GroupAdjacentSourceSequenceWithSomeNullKeys() { using var source = AsyncEnumerable.Range(1, 5) diff --git a/Tests/SuperLinq.Async.Tests/HasDuplicatesTest.cs b/Tests/SuperLinq.Async.Tests/HasDuplicatesTest.cs new file mode 100644 index 000000000..3132b4e6e --- /dev/null +++ b/Tests/SuperLinq.Async.Tests/HasDuplicatesTest.cs @@ -0,0 +1,43 @@ +namespace SuperLinq.Async.Tests; + +public sealed class HasDuplicatesTest +{ + [Test] + public async Task DuplicatesDoesNotEnumerateUnnecessarily() + { + using var ts = AsyncSeq(1, 2, 3).Concat(AsyncSeqExceptionAt(2)).AsTestingSequence(); + + var result = await ts.HasDuplicates(); + Assert.True(result); + } + + [Test] + [Arguments(new int[] { 1, 2, 3 }, false)] + [Arguments(new int[] { 1, 2, 1, 3, 1, 2, 1 }, true)] + [Arguments(new int[] { 3, 3, 2, 2, 1, 1 }, true)] + public async Task DuplicatesBehavior(IEnumerable source, bool expected) + { + await using var ts = source.AsTestingSequence(); + + var result = await ts.HasDuplicates(); + Assert.Equal(expected, result); + } + + public static IEnumerable<(IEnumerable source, StringComparer comparer, bool expected)> GetStringParameters() => + [ + (["foo", "bar", "qux"], StringComparer.Ordinal, false), + (["foo", "FOO", "bar", "qux"], StringComparer.Ordinal, false), + (["foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, true), + (["Bar", "foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, true), + ]; + + [Test] + [MethodDataSource(nameof(GetStringParameters))] + public async Task DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, bool expected) + { + await using var ts = source.AsTestingSequence(); + + var result = await ts.HasDuplicates(comparer); + Assert.Equal(expected, result); + } +} diff --git a/Tests/SuperLinq.Async.Test/IfTest.cs b/Tests/SuperLinq.Async.Tests/IfTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/IfTest.cs rename to Tests/SuperLinq.Async.Tests/IfTest.cs index d116264a8..6dcf62024 100644 --- a/Tests/SuperLinq.Async.Test/IfTest.cs +++ b/Tests/SuperLinq.Async.Tests/IfTest.cs @@ -1,15 +1,15 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class IfTest { - [Fact] + [Test] public void IfIsLazy() { _ = AsyncSuperEnumerable.If(BreakingFunc.Of(), new AsyncBreakingSequence()); _ = AsyncSuperEnumerable.If(BreakingFunc.Of>(), new AsyncBreakingSequence()); } - [Fact] + [Test] public async Task IfBehavior() { var starts = 0; @@ -26,7 +26,7 @@ public async Task IfBehavior() await seq.AssertSequenceEqual(); } - [Fact] + [Test] public void IfElseIsLazy() { _ = AsyncSuperEnumerable.If( @@ -39,7 +39,7 @@ public void IfElseIsLazy() new AsyncBreakingSequence()); } - [Fact] + [Test] public async Task IfElseBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Async.Test/IndexByTest.cs b/Tests/SuperLinq.Async.Tests/IndexByTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/IndexByTest.cs rename to Tests/SuperLinq.Async.Tests/IndexByTest.cs index 7b203b826..24463ef3d 100644 --- a/Tests/SuperLinq.Async.Test/IndexByTest.cs +++ b/Tests/SuperLinq.Async.Tests/IndexByTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class IndexByTest { - [Fact] + [Test] public async Task IndexBySimpleTest() { using var source = TestingSequence.Of("ana", "beatriz", "carla", "bob", "davi", "adriano", "angelo", "carlos"); @@ -19,7 +19,7 @@ await result.AssertSequenceEqual( (1, "carlos")); } - [Fact] + [Test] public async Task IndexByWithSecondOccurenceImmediatelyAfterFirst() { using var source = "jaffer".AsTestingSequence(); @@ -28,7 +28,7 @@ public async Task IndexByWithSecondOccurenceImmediatelyAfterFirst() await result.AssertSequenceEqual((0, 'j'), (0, 'a'), (0, 'f'), (1, 'f'), (0, 'e'), (0, 'r')); } - [Fact] + [Test] public async Task IndexByWithEqualityComparer() { using var source = TestingSequence.Of("a", "B", "c", "A", "b", "A"); @@ -37,13 +37,13 @@ public async Task IndexByWithEqualityComparer() await result.AssertSequenceEqual((0, "a"), (0, "B"), (0, "c"), (1, "A"), (1, "b"), (2, "A")); } - [Fact] + [Test] public void IndexByIsLazy() { _ = new AsyncBreakingSequence().IndexBy(BreakingFunc.Of()); } - [Fact] + [Test] public async Task IndexByWithSomeNullKeys() { using var source = TestingSequence.Of("foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"); @@ -52,7 +52,7 @@ public async Task IndexByWithSomeNullKeys() await result.AssertSequenceEqual((0, "foo"), (0, null), (0, "bar"), (0, "baz"), (1, null), (2, null), (1, "baz"), (1, "bar"), (3, null), (1, "foo")); } - [Fact] + [Test] public async Task IndexByDoesNotIterateUnnecessaryElements() { using var source = AsyncSuperEnumerable diff --git a/Tests/SuperLinq.Async.Test/IndexOfTest.cs b/Tests/SuperLinq.Async.Tests/IndexOfTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/IndexOfTest.cs rename to Tests/SuperLinq.Async.Tests/IndexOfTest.cs index ad55ad635..ec621a7b6 100644 --- a/Tests/SuperLinq.Async.Test/IndexOfTest.cs +++ b/Tests/SuperLinq.Async.Tests/IndexOfTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class IndexOfTest { - [Fact] + [Test] public async Task IndexOfWithNegativeCount() { await using var sequence = TestingSequence.Of(1); @@ -12,14 +12,14 @@ public async Task IndexOfWithNegativeCount() await sequence.IndexOf(1, 1, -1)); } - [Fact] + [Test] public async Task IndexOfWorksWithEmptySequence() { await using var sequence = TestingSequence.Of(); Assert.Equal(-1, await sequence.IndexOf(5)); } - [Fact] + [Test] public async Task IndexOfFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -28,7 +28,7 @@ public async Task IndexOfFromStart() await sequence.IndexOf(102)); } - [Fact] + [Test] public async Task IndexOfFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -37,7 +37,7 @@ public async Task IndexOfFromStartCount() await sequence.IndexOf(102, 0, 3)); } - [Fact] + [Test] public async Task IndexOfFromStartIndex() { await using var sequence = AsyncEnumerable.Range(100, 5).Concat(AsyncEnumerable.Range(100, 5)).AsTestingSequence(); @@ -46,7 +46,7 @@ public async Task IndexOfFromStartIndex() await sequence.IndexOf(102, 5)); } - [Fact] + [Test] public async Task IndexOfFromEndIndex() { await using var sequence = AsyncEnumerable.Range(100, 5).Concat(AsyncEnumerable.Range(100, 5)).AsTestingSequence(); @@ -55,7 +55,7 @@ public async Task IndexOfFromEndIndex() await sequence.IndexOf(102, ^5)); } - [Fact] + [Test] public async Task IndexOfMissingValueFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -64,7 +64,7 @@ public async Task IndexOfMissingValueFromStart() await sequence.IndexOf(95)); } - [Fact] + [Test] public async Task IndexOfMissingValueFromEnd() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -73,7 +73,7 @@ public async Task IndexOfMissingValueFromEnd() await sequence.IndexOf(95, ^5)); } - [Fact] + [Test] public async Task IndexOfMissingValueFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -82,7 +82,7 @@ public async Task IndexOfMissingValueFromStartCount() await sequence.IndexOf(104, 0, 4)); } - [Fact] + [Test] public async Task IndexOfMissingValueFromEndCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -91,7 +91,7 @@ public async Task IndexOfMissingValueFromEndCount() await sequence.IndexOf(104, ^5, 4)); } - [Fact] + [Test] public async Task IndexOfDoesNotIterateUnnecessaryElements() { await using var source = SuperLinq.SuperEnumerable @@ -109,7 +109,7 @@ public async Task IndexOfDoesNotIterateUnnecessaryElements() Assert.Equal(4, await source.IndexOf("davi")); } - [Fact] + [Test] public async Task IndexOfDoesNotIterateUnnecessaryElementsCount() { await using var source = SuperLinq.SuperEnumerable diff --git a/Tests/SuperLinq.Async.Test/IndexTest.cs b/Tests/SuperLinq.Async.Tests/IndexTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/IndexTest.cs rename to Tests/SuperLinq.Async.Tests/IndexTest.cs index db44ed302..858af82bd 100644 --- a/Tests/SuperLinq.Async.Test/IndexTest.cs +++ b/Tests/SuperLinq.Async.Tests/IndexTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class IndexTest { - [Fact] + [Test] public void IndexIsLazy() { var bs = new AsyncBreakingSequence(); @@ -14,7 +14,7 @@ public void IndexIsLazy() private const string Two = "two"; private const string Three = "three"; - [Fact] + [Test] public async Task IndexSequence() { await using var seq = TestingSequence.Of(One, Two, Three); @@ -25,7 +25,7 @@ await result.AssertSequenceEqual( (2, Three)); } - [Fact] + [Test] public async Task IndexSequenceStartIndex() { await using var seq = TestingSequence.Of(One, Two, Three); diff --git a/Tests/SuperLinq.Async.Test/InnerJoinTest.cs b/Tests/SuperLinq.Async.Tests/InnerJoinTest.cs similarity index 85% rename from Tests/SuperLinq.Async.Test/InnerJoinTest.cs rename to Tests/SuperLinq.Async.Tests/InnerJoinTest.cs index 023d9383f..bdd4e0ba3 100644 --- a/Tests/SuperLinq.Async.Test/InnerJoinTest.cs +++ b/Tests/SuperLinq.Async.Tests/InnerJoinTest.cs @@ -1,6 +1,6 @@ -using static Test.Async.JoinOperation; +using static SuperLinq.Async.Tests.JoinOperation; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class InnerJoinTest { @@ -8,7 +8,8 @@ public sealed class InnerJoinTest IAsyncEnumerable<(string, string)> left, IAsyncEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Loop, false) => left.InnerLoopJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -21,10 +22,11 @@ public sealed class InnerJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetInnerJoins() => - new[] { Loop, Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetInnerJoins() => + new[] { Loop, Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public void InnerJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new AsyncBreakingSequence<(string, string)>(); @@ -33,7 +35,8 @@ public void InnerJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public async Task InnerJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -54,7 +57,8 @@ await result.AssertCollectionEqual( (bar1, bar3)); } - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public async Task InnerJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -68,7 +72,8 @@ public async Task InnerJoinEmptyLeft(JoinOperation op, bool passProjectors) await result.AssertCollectionEqual(); } - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public async Task InnerJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Async.Test/InsertTest.cs b/Tests/SuperLinq.Async.Tests/InsertTest.cs similarity index 78% rename from Tests/SuperLinq.Async.Test/InsertTest.cs rename to Tests/SuperLinq.Async.Tests/InsertTest.cs index 12ef2372f..d60041f34 100644 --- a/Tests/SuperLinq.Async.Test/InsertTest.cs +++ b/Tests/SuperLinq.Async.Tests/InsertTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class InsertTest { - [Fact] + [Test] public void InsertWithNegativeIndex() { _ = Assert.Throws(() => @@ -12,10 +12,10 @@ public void InsertWithNegativeIndex() .Insert(AsyncSeq(97, 98, 99), -1)); } - [Theory] - [InlineData(7)] - [InlineData(8)] - [InlineData(9)] + [Test] + [Arguments(7)] + [Arguments(8)] + [Arguments(9)] public async Task InsertWithIndexGreaterThanSourceLengthMaterialized(int count) { var seq1 = AsyncEnumerable.Range(0, count); @@ -31,10 +31,10 @@ await result.ForEachAsync((e, index) => Assert.Equal(index, e))); } - [Theory] - [InlineData(7)] - [InlineData(8)] - [InlineData(9)] + [Test] + [Arguments(7)] + [Arguments(8)] + [Arguments(9)] public async Task InsertWithIndexGreaterThanSourceLengthLazy(int count) { var seq1 = AsyncEnumerable.Range(0, count); @@ -48,11 +48,11 @@ public async Task InsertWithIndexGreaterThanSourceLengthLazy(int count) Assert.Equal(await seq1.ToListAsync(), await result.ToListAsync()); } - [Theory] - [InlineData(3, 0)] - [InlineData(3, 1)] - [InlineData(3, 2)] - [InlineData(3, 3)] + [Test] + [Arguments(3, 0)] + [Arguments(3, 1)] + [Arguments(3, 2)] + [Arguments(3, 3)] public async Task Insert(int count, int index) { var seq1 = AsyncEnumerable.Range(1, count); @@ -69,20 +69,20 @@ public async Task Insert(int count, int index) Assert.Equal(await expectations.ToListAsync(), await result.ToListAsync()); } - [Fact] + [Test] public void InsertIsLazy() { _ = new AsyncBreakingSequence().Insert(new AsyncBreakingSequence(), 0); } - [Fact] + [Test] public void BacksertIsLazy() { _ = new AsyncBreakingSequence().Insert(new AsyncBreakingSequence(), ^0); } - [Theory] - [InlineData(new[] { 1, 2, 3 }, 4, new[] { 9 })] + [Test] + [Arguments(new[] { 1, 2, 3 }, 4, new[] { 9 })] public async Task BacksertWithIndexGreaterThanSourceLength(int[] seq1, int index, int[] seq2) { await using var test1 = seq1.AsTestingSequence(); @@ -93,11 +93,11 @@ public async Task BacksertWithIndexGreaterThanSourceLength(int[] seq1, int index _ = await Assert.ThrowsAsync(async () => await result.ElementAtAsync(0)); } - [Theory] - [InlineData(new[] { 1, 2, 3 }, 0, new[] { 8, 9 }, new[] { 1, 2, 3, 8, 9 })] - [InlineData(new[] { 1, 2, 3 }, 1, new[] { 8, 9 }, new[] { 1, 2, 8, 9, 3 })] - [InlineData(new[] { 1, 2, 3 }, 2, new[] { 8, 9 }, new[] { 1, 8, 9, 2, 3 })] - [InlineData(new[] { 1, 2, 3 }, 3, new[] { 8, 9 }, new[] { 8, 9, 1, 2, 3 })] + [Test] + [Arguments(new[] { 1, 2, 3 }, 0, new[] { 8, 9 }, new[] { 1, 2, 3, 8, 9 })] + [Arguments(new[] { 1, 2, 3 }, 1, new[] { 8, 9 }, new[] { 1, 2, 8, 9, 3 })] + [Arguments(new[] { 1, 2, 3 }, 2, new[] { 8, 9 }, new[] { 1, 8, 9, 2, 3 })] + [Arguments(new[] { 1, 2, 3 }, 3, new[] { 8, 9 }, new[] { 8, 9, 1, 2, 3 })] public async Task Backsert(int[] seq1, int index, int[] seq2, int[] expected) { await using var test1 = seq1.AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/InterleaveTest.cs b/Tests/SuperLinq.Async.Tests/InterleaveTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/InterleaveTest.cs rename to Tests/SuperLinq.Async.Tests/InterleaveTest.cs index 89c3e76b7..7a9deff06 100644 --- a/Tests/SuperLinq.Async.Test/InterleaveTest.cs +++ b/Tests/SuperLinq.Async.Tests/InterleaveTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the Interleave operator @@ -8,7 +8,7 @@ public sealed class InterleaveTests /// /// Verify that Interleave behaves in a lazy manner /// - [Fact] + [Test] public void TestInterleaveIsLazy() { _ = new AsyncBreakingSequence().Interleave(new AsyncBreakingSequence()); @@ -18,7 +18,7 @@ public void TestInterleaveIsLazy() /// Verify that interleaving disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public async Task TestInterleaveDisposesOnErrorAtGetEnumerator() { await using var sequenceA = TestingSequence.Of(); @@ -32,7 +32,7 @@ public async Task TestInterleaveDisposesOnErrorAtGetEnumerator() /// Verify that interleaving disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public async Task TestInterleaveDisposesOnErrorAtMoveNext() { await using var sequenceA = TestingSequence.Of(); @@ -45,7 +45,7 @@ public async Task TestInterleaveDisposesOnErrorAtMoveNext() /// /// Verify that interleaving do not call enumerators MoveNext method eagerly /// - [Fact] + [Test] public async Task TestInterleaveDoNoCallMoveNextEagerly() { await using var sequenceA = AsyncEnumerable.Range(1, 1).AsTestingSequence(); @@ -57,7 +57,7 @@ public async Task TestInterleaveDoNoCallMoveNextEagerly() /// /// Verify that two balanced sequences will interleave all of their elements /// - [Fact] + [Test] public async Task TestInterleaveTwoBalancedSequences() { await using var sequenceA = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -70,7 +70,7 @@ public async Task TestInterleaveTwoBalancedSequences() /// /// Verify that interleaving two empty sequences results in an empty sequence /// - [Fact] + [Test] public async Task TestInterleaveTwoEmptySequences() { await using var sequenceA = TestingSequence.Of(); @@ -84,7 +84,7 @@ public async Task TestInterleaveTwoEmptySequences() /// Verify that interleaving two unequal sequences with the Skip strategy results in /// the shorter sequence being omitted from the interleave operation when consumed /// - [Fact] + [Test] public async Task TestInterleaveTwoImbalanceStrategySkip() { await using var sequenceA = TestingSequence.Of(0, 0, 0, 0, 0, 0); @@ -97,7 +97,7 @@ public async Task TestInterleaveTwoImbalanceStrategySkip() /// /// Verify that interleaving multiple empty sequences results in an empty sequence /// - [Fact] + [Test] public async Task TestInterleaveManyEmptySequences() { await using var sequenceA = TestingSequence.Of(); @@ -114,7 +114,7 @@ public async Task TestInterleaveManyEmptySequences() /// Verify that interleaving multiple unequal sequences with the Skip strategy /// results in sequences being omitted form the interleave operation when consumed /// - [Fact] + [Test] public async Task TestInterleaveManyImbalanceStrategySkip() { await using var sequenceA = TestingSequence.Of(1, 5, 8, 11, 14, 16); diff --git a/Tests/SuperLinq.Async.Test/LagTest.cs b/Tests/SuperLinq.Async.Tests/LagTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/LagTest.cs rename to Tests/SuperLinq.Async.Tests/LagTest.cs index 8d13b0f7d..0f1460452 100644 --- a/Tests/SuperLinq.Async.Test/LagTest.cs +++ b/Tests/SuperLinq.Async.Tests/LagTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the Lag operator @@ -8,7 +8,7 @@ public sealed class LagTests /// /// Verify that lag behaves in a lazy manner. /// - [Fact] + [Test] public void TestLagIsLazy() { _ = new AsyncBreakingSequence().Lag(5, BreakingFunc.Of()); @@ -18,7 +18,7 @@ public void TestLagIsLazy() /// /// Verify that lagging by a negative offset results in an exception. /// - [Fact] + [Test] public void TestLagNegativeOffsetException() { _ = Assert.Throws(() => @@ -28,7 +28,7 @@ public void TestLagNegativeOffsetException() /// /// Verify that attempting to lag by a zero offset will result in an exception /// - [Fact] + [Test] public void TestLagZeroOffset() { _ = Assert.Throws(() => @@ -38,7 +38,7 @@ public void TestLagZeroOffset() /// /// Verify that lag can accept an propagate a default value passed to it. /// - [Fact] + [Test] public async Task TestLagExplicitDefaultValue() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -48,7 +48,7 @@ public async Task TestLagExplicitDefaultValue() result.Take(10).AssertSequenceEqual(Enumerable.Repeat(-1, 10)); } - [Fact] + [Test] public async Task TestLagTuple() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -62,7 +62,7 @@ public async Task TestLagTuple() /// /// Verify that lag will use default(T) if a specific default value is not supplied for the lag value. /// - [Fact] + [Test] public async Task TestLagImplicitDefaultValue() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -76,7 +76,7 @@ public async Task TestLagImplicitDefaultValue() /// Verify that if the lag offset is greater than the sequence length lag /// still yields all of the elements of the source sequence. /// - [Fact] + [Test] public async Task TestLagOffsetGreaterThanSequenceLength() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -90,7 +90,7 @@ public async Task TestLagOffsetGreaterThanSequenceLength() /// Verify that lag actually yields the correct pair of values from the sequence /// when offsetting by a single item. /// - [Fact] + [Test] public async Task TestLagPassesCorrectLagValueOffsetBy1() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -104,7 +104,7 @@ public async Task TestLagPassesCorrectLagValueOffsetBy1() /// Verify that lag yields the correct pair of values from the sequence when /// offsetting by more than a single item. /// - [Fact] + [Test] public async Task TestLagPassesCorrectLagValuesOffsetBy2() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -115,7 +115,7 @@ public async Task TestLagPassesCorrectLagValuesOffsetBy2() Assert.True(result.Take(2).All(x => (x.A - x.B) == x.A)); } - [Fact] + [Test] public async Task TestLagWithNullableReferences() { await using var words = TestingSequence.Of("foo", "bar", "baz", "qux"); @@ -127,7 +127,7 @@ await result.AssertSequenceEqual( new { A = "qux", B = (string?)"bar" }); } - [Fact] + [Test] public async Task TestLagWithNonNullableReferences() { await using var words = TestingSequence.Of("foo", "bar", "baz", "qux"); diff --git a/Tests/SuperLinq.Async.Test/LastIndexOfTest.cs b/Tests/SuperLinq.Async.Tests/LastIndexOfTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/LastIndexOfTest.cs rename to Tests/SuperLinq.Async.Tests/LastIndexOfTest.cs index e17e603ce..e2672301e 100644 --- a/Tests/SuperLinq.Async.Test/LastIndexOfTest.cs +++ b/Tests/SuperLinq.Async.Tests/LastIndexOfTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class LastIndexOfTest { - [Fact] + [Test] public async Task LastIndexOfWithNegativeCount() { await using var sequence = TestingSequence.Of(1); @@ -12,14 +12,14 @@ public async Task LastIndexOfWithNegativeCount() await sequence.LastIndexOf(1, 1, -1)); } - [Fact] + [Test] public async Task LastIndexOfWorksWithEmptySequence() { await using var sequence = Array.Empty().AsTestingSequence(); Assert.Equal(-1, await sequence.LastIndexOf(5)); } - [Fact] + [Test] public async Task LastIndexOfFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -30,7 +30,7 @@ public async Task LastIndexOfFromStart() await sequence.LastIndexOf(102)); } - [Fact] + [Test] public async Task LastIndexOfFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -41,7 +41,7 @@ public async Task LastIndexOfFromStartCount() await sequence.LastIndexOf(102, int.MaxValue, 8)); } - [Fact] + [Test] public async Task LastIndexOfFromStartIndex() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -52,7 +52,7 @@ public async Task LastIndexOfFromStartIndex() await sequence.LastIndexOf(102, 8)); } - [Fact] + [Test] public async Task LastIndexOfFromEndIndex() { await using var sequence = AsyncEnumerable.Range(100, 5) @@ -63,7 +63,7 @@ public async Task LastIndexOfFromEndIndex() await sequence.LastIndexOf(102, ^3)); } - [Fact] + [Test] public async Task LastIndexOfMissingValueFromStart() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -72,7 +72,7 @@ public async Task LastIndexOfMissingValueFromStart() await sequence.LastIndexOf(95)); } - [Fact] + [Test] public async Task LastIndexOfMissingValueFromEnd() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -81,7 +81,7 @@ public async Task LastIndexOfMissingValueFromEnd() await sequence.LastIndexOf(95, ^5)); } - [Fact] + [Test] public async Task LastIndexOfMissingValueFromStartCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); @@ -90,7 +90,7 @@ public async Task LastIndexOfMissingValueFromStartCount() await sequence.LastIndexOf(100, int.MaxValue, 4)); } - [Fact] + [Test] public async Task LastIndexOfMissingValueFromEndCount() { await using var sequence = AsyncEnumerable.Range(100, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/LeadTest.cs b/Tests/SuperLinq.Async.Tests/LeadTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/LeadTest.cs rename to Tests/SuperLinq.Async.Tests/LeadTest.cs index eb91faf44..bce59d4a1 100644 --- a/Tests/SuperLinq.Async.Test/LeadTest.cs +++ b/Tests/SuperLinq.Async.Tests/LeadTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the Lead operator. @@ -8,7 +8,7 @@ public sealed class LeadTests /// /// Verify that Lead() behaves in a lazy manner. /// - [Fact] + [Test] public void TestLeadIsLazy() { _ = new AsyncBreakingSequence().Lead(5, BreakingFunc.Of()); @@ -18,7 +18,7 @@ public void TestLeadIsLazy() /// /// Verify that attempting to lead by a negative offset will result in an exception. /// - [Fact] + [Test] public void TestLeadNegativeOffset() { _ = Assert.Throws(() => @@ -28,7 +28,7 @@ public void TestLeadNegativeOffset() /// /// Verify that attempting to lead by a zero offset will result in an exception. /// - [Fact] + [Test] public void TestLeadZeroOffset() { _ = Assert.Throws(() => @@ -38,7 +38,7 @@ public void TestLeadZeroOffset() /// /// Verify that lead can accept and propagate a default value passed to it. /// - [Fact] + [Test] public async Task TestLeadExplicitDefaultValue() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -48,7 +48,7 @@ public async Task TestLeadExplicitDefaultValue() result.Skip(100 - 10).AssertSequenceEqual(Enumerable.Repeat(-1, 10)); } - [Fact] + [Test] public async Task TestLeadTuple() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -62,7 +62,7 @@ public async Task TestLeadTuple() /// /// Verify that Lead() will use default(T) if a specific default value is not supplied for the lead value. /// - [Fact] + [Test] public async Task TestLeadImplicitDefaultValue() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -76,7 +76,7 @@ public async Task TestLeadImplicitDefaultValue() /// Verify that if the lead offset is greater than the length of the sequence /// Lead() still yield all of the elements of the source sequence. /// - [Fact] + [Test] public async Task TestLeadOffsetGreaterThanSequenceLength() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -92,7 +92,7 @@ public async Task TestLeadOffsetGreaterThanSequenceLength() /// Verify that Lead() actually yields the correct pair of values from the sequence /// when the lead offset is 1. /// - [Fact] + [Test] public async Task TestLeadPassesCorrectValueOffsetBy1() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -108,7 +108,7 @@ public async Task TestLeadPassesCorrectValueOffsetBy1() /// Verify that Lead() yields the correct pair of values from the sequence /// when the lead offset is greater than 1. /// - [Fact] + [Test] public async Task TestLeadPassesCorrectValueOffsetBy2() { await using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -121,7 +121,7 @@ public async Task TestLeadPassesCorrectValueOffsetBy2() Assert.True(result.Skip(100 - 2).All(x => x.B == 101 && (x.A is 99 or 100))); } - [Fact] + [Test] public async Task TestLagWithNullableReferences() { await using var words = TestingSequence.Of("foo", "bar", "baz", "qux"); @@ -134,7 +134,7 @@ await result.AssertSequenceEqual( new { A = "qux", B = (string?)null }); } - [Fact] + [Test] public async Task TestLagWithNonNullableReferences() { await using var words = TestingSequence.Of("foo", "bar", "baz", "qux"); diff --git a/Tests/SuperLinq.Async.Test/LeftOuterJoin.cs b/Tests/SuperLinq.Async.Tests/LeftOuterJoin.cs similarity index 85% rename from Tests/SuperLinq.Async.Test/LeftOuterJoin.cs rename to Tests/SuperLinq.Async.Tests/LeftOuterJoin.cs index ae33bf661..980a148fb 100644 --- a/Tests/SuperLinq.Async.Test/LeftOuterJoin.cs +++ b/Tests/SuperLinq.Async.Tests/LeftOuterJoin.cs @@ -1,6 +1,6 @@ -using static Test.Async.JoinOperation; +using static SuperLinq.Async.Tests.JoinOperation; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class LeftOuterJoinTest { @@ -8,7 +8,8 @@ public sealed class LeftOuterJoinTest IAsyncEnumerable<(string, string)> left, IAsyncEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Loop, false) => left.LeftOuterLoopJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -21,10 +22,11 @@ public sealed class LeftOuterJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetLeftOuterJoins() => - new[] { Loop, Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetLeftOuterJoins() => + new[] { Loop, Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public void LeftOuterJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new AsyncBreakingSequence<(string, string)>(); @@ -33,7 +35,8 @@ public void LeftOuterJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public async Task LeftOuterJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -56,7 +59,8 @@ await result.AssertCollectionEqual( (qux, default)); } - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public async Task LeftOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -70,7 +74,8 @@ public async Task LeftOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) await result.AssertCollectionEqual(); } - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public async Task LeftOuterJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Async.Test/MaxItemsTest.cs b/Tests/SuperLinq.Async.Tests/MaxItemsTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/MaxItemsTest.cs rename to Tests/SuperLinq.Async.Tests/MaxItemsTest.cs index f706651c2..715d9525e 100644 --- a/Tests/SuperLinq.Async.Test/MaxItemsTest.cs +++ b/Tests/SuperLinq.Async.Tests/MaxItemsTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class MaxItemsTest { - [Fact] + [Test] public void MaxItemsIsLazy() { _ = new AsyncBreakingSequence().MaxItems(); } - [Fact] + [Test] public async Task MaxItemsEmptyList() { await using var seq = TestingSequence.Of(); @@ -16,7 +16,7 @@ public async Task MaxItemsEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MaxItemsBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -24,13 +24,13 @@ public async Task MaxItemsBehavior() await result.AssertSequenceEqual(5, 5); } - [Fact] + [Test] public void MaxItemsComparerIsLazy() { _ = new AsyncBreakingSequence().MaxItems(comparer: null); } - [Fact] + [Test] public async Task MaxItemsComparerEmptyList() { await using var seq = TestingSequence.Of(); @@ -38,7 +38,7 @@ public async Task MaxItemsComparerEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MaxItemsComparerBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -46,14 +46,14 @@ public async Task MaxItemsComparerBehavior() await result.AssertSequenceEqual(2, 2, 5, 5, 2, 2); } - [Fact] + [Test] public void MaxItemsByIsLazy() { _ = new AsyncBreakingSequence().MaxItemsBy(BreakingFunc.Of()); _ = new AsyncBreakingSequence().MaxByWithTies(BreakingFunc.Of()); } - [Fact] + [Test] public async Task MaxItemsByEmptyList() { await using var seq = TestingSequence.Of(); @@ -61,7 +61,7 @@ public async Task MaxItemsByEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MaxItemsByBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -69,14 +69,14 @@ public async Task MaxItemsByBehavior() await result.AssertSequenceEqual(0, 0, 0, 0); } - [Fact] + [Test] public void MaxItemsByComparerIsLazy() { _ = new AsyncBreakingSequence().MaxItemsBy(BreakingFunc.Of(), comparer: null); _ = new AsyncBreakingSequence().MaxByWithTies(BreakingFunc.Of(), comparer: null); } - [Fact] + [Test] public async Task MaxItemsByComparerEmptyList() { await using var seq = TestingSequence.Of(); @@ -84,7 +84,7 @@ public async Task MaxItemsByComparerEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MaxItemsByComparerBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); diff --git a/Tests/SuperLinq.Async.Test/MemoizeTest.cs b/Tests/SuperLinq.Async.Tests/MemoizeTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/MemoizeTest.cs rename to Tests/SuperLinq.Async.Tests/MemoizeTest.cs index 668a75ac5..197b9f56d 100644 --- a/Tests/SuperLinq.Async.Test/MemoizeTest.cs +++ b/Tests/SuperLinq.Async.Tests/MemoizeTest.cs @@ -1,16 +1,16 @@ using System.Collections; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class MemoizeTest { - [Fact] + [Test] public void MemoizeIsLazy() { _ = new AsyncBreakingSequence().Memoize(); } - [Fact] + [Test] public async Task MemoizeSimpleUse() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -22,7 +22,7 @@ public async Task MemoizeSimpleUse() Assert.Equal(10, buffer.Count); } - [Fact] + [Test] public async Task MemoizeReturningExpectedElementsWhenUsedAtInnerForEach() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -84,7 +84,7 @@ static async IAsyncEnumerable InnerForEach(IAsyncEnumerable source) } } - [Fact] + [Test] public static async Task MemoizeThrowsWhenCacheDisposedDuringIteration() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -99,7 +99,7 @@ public static async Task MemoizeThrowsWhenCacheDisposedDuringIteration() async () => await reader.Read()); } - [Fact] + [Test] public static async Task MemoizeThrowsWhenResetDuringIteration() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -116,7 +116,7 @@ public static async Task MemoizeThrowsWhenResetDuringIteration() Assert.Equal("Buffer reset during iteration.", ex.Message); } - [Fact] + [Test] public async Task MemoizeThrowsWhenGettingAfterDispose() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -130,7 +130,7 @@ public async Task MemoizeThrowsWhenGettingAfterDispose() async () => await buffer.Consume()); } - [Fact] + [Test] public static async Task MemoizeThrowsWhenResettingAfterDispose() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -144,7 +144,7 @@ public static async Task MemoizeThrowsWhenResettingAfterDispose() async () => await buffer.Reset()); } - [Fact] + [Test] public async Task MemoizeWithPartialIterationBeforeCompleteIteration() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -159,7 +159,7 @@ public async Task MemoizeWithPartialIterationBeforeCompleteIteration() Assert.Equal(10, buffer.Count); } - [Fact] + [Test] public async Task MemoizeWithDisposeOnEarlyExitTrue() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -174,7 +174,7 @@ public async Task MemoizeWithDisposeOnEarlyExitTrue() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public async Task MemoizeDisposesAfterSourceIsIteratedEntirely() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -185,7 +185,7 @@ public async Task MemoizeDisposesAfterSourceIsIteratedEntirely() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public async Task MemoizeEnumeratesOnlyOnce() { await using var seq = AsyncEnumerable.Range(1, 10).AsTestingSequence(); @@ -196,7 +196,7 @@ public async Task MemoizeEnumeratesOnlyOnce() await buffer.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public static async Task MemoizeRestartsAfterReset() { var starts = 0; @@ -219,7 +219,7 @@ IEnumerable TestSequence() Assert.Equal(2, starts); } - [Fact] + [Test] public async Task MemoizeRethrowsErrorDuringIterationToAllsUntilReset() { await using var xs = AsyncSeqExceptionAt(2).AsTestingSequence(maxEnumerations: 2); @@ -243,7 +243,7 @@ public async Task MemoizeRethrowsErrorDuringIterationToAllsUntilReset() Assert.Equal(1, await r1.Read()); } - [Fact] + [Test] public async Task MemoizeRethrowsErrorDuringIterationStartToAllsUntilReset() { var i = 0; @@ -273,7 +273,7 @@ public async Task MemoizeRethrowsErrorDuringIterationStartToAllsUntilReset() Assert.Equal(1, buffer.Count); } - [Fact] + [Test] public async Task MemoizeRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { using var seq = new FailingEnumerable().AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Async.Test/MinItemsTest.cs b/Tests/SuperLinq.Async.Tests/MinItemsTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/MinItemsTest.cs rename to Tests/SuperLinq.Async.Tests/MinItemsTest.cs index 68ee0bb52..5709d1baa 100644 --- a/Tests/SuperLinq.Async.Test/MinItemsTest.cs +++ b/Tests/SuperLinq.Async.Tests/MinItemsTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class MinItemsTest { - [Fact] + [Test] public void MinItemsIsLazy() { _ = new AsyncBreakingSequence().MinItems(); } - [Fact] + [Test] public async Task MinItemsEmptyList() { await using var seq = TestingSequence.Of(); @@ -16,7 +16,7 @@ public async Task MinItemsEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MinItemsBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -24,13 +24,13 @@ public async Task MinItemsBehavior() await result.AssertSequenceEqual(0, 0, 0, 0); } - [Fact] + [Test] public void MinItemsComparerIsLazy() { _ = new AsyncBreakingSequence().MinItems(comparer: null); } - [Fact] + [Test] public async Task MinItemsComparerEmptyList() { await using var seq = TestingSequence.Of(); @@ -38,7 +38,7 @@ public async Task MinItemsComparerEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MinItemsComparerBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -46,14 +46,14 @@ public async Task MinItemsComparerBehavior() await result.AssertSequenceEqual(0, 0, 3, 3, 0, 3, 3, 0); } - [Fact] + [Test] public void MinItemsByIsLazy() { _ = new AsyncBreakingSequence().MinItemsBy(BreakingFunc.Of()); _ = new AsyncBreakingSequence().MinByWithTies(BreakingFunc.Of()); } - [Fact] + [Test] public async Task MinItemsByEmptyList() { await using var seq = TestingSequence.Of(); @@ -61,7 +61,7 @@ public async Task MinItemsByEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MinItemsByBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -69,7 +69,7 @@ public async Task MinItemsByBehavior() await result.AssertSequenceEqual(5, 5); } - [Fact] + [Test] public void MinItemsByComparerIsLazy() { _ = new AsyncBreakingSequence().MinItemsBy(BreakingFunc.Of(), comparer: null); @@ -77,7 +77,7 @@ public void MinItemsByComparerIsLazy() (BreakingFunc.Of(), comparer: null); } - [Fact] + [Test] public async Task MinItemsByComparerEmptyList() { await using var seq = TestingSequence.Of(); @@ -85,7 +85,7 @@ public async Task MinItemsByComparerEmptyList() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task MinItemsByComparerBehavior() { await using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); diff --git a/Tests/SuperLinq.Async.Test/NullArgumentTest.cs b/Tests/SuperLinq.Async.Tests/NullArgumentTest.cs similarity index 90% rename from Tests/SuperLinq.Async.Test/NullArgumentTest.cs rename to Tests/SuperLinq.Async.Tests/NullArgumentTest.cs index 2eee39d8a..6dee167d5 100644 --- a/Tests/SuperLinq.Async.Test/NullArgumentTest.cs +++ b/Tests/SuperLinq.Async.Tests/NullArgumentTest.cs @@ -7,20 +7,22 @@ using System.Reflection; using Debug = System.Diagnostics.Debug; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class NullArgumentTest { - [Theory, MemberData(nameof(GetNotNullInlineDatas))] - public void NotNull(Action inlineData) => - inlineData(); - - [Theory, MemberData(nameof(GetCanBeNullInlineDatas))] - public void CanBeNull(Action inlineData) => - inlineData(); - - public static IEnumerable GetNotNullInlineDatas() => - GetInlineDatas(canBeNull: false, inlineDataFactory: (method, args, paramName) => () => + [Test] + [MethodDataSource(nameof(GetNotNullArguments))] + public void NotNull(Action arguments) => + arguments(); + + [Test] + [MethodDataSource(nameof(GetCanBeNullArguments))] + public void CanBeNull(Action arguments) => + arguments(); + + public static IEnumerable GetNotNullArguments() => + GetArguments(canBeNull: false, argumentsFactory: (method, args, paramName) => () => { var tie = Assert.Throws(() => method.Invoke(null, args)); @@ -32,8 +34,8 @@ public static IEnumerable GetNotNullInlineDatas() => Assert.Equal(paramName, ane.ParamName); }); - public static IEnumerable GetCanBeNullInlineDatas() => - GetInlineDatas(canBeNull: true, inlineDataFactory: (method, args, paramName) => () => + public static IEnumerable GetCanBeNullArguments() => + GetArguments(canBeNull: true, argumentsFactory: (method, args, paramName) => () => { try { @@ -52,13 +54,13 @@ tie.InnerException is ArgumentNullException ane nameof(AsyncSuperEnumerable.CopyTo), ]; - private static IEnumerable GetInlineDatas(bool canBeNull, Func inlineDataFactory) => + private static IEnumerable GetArguments(bool canBeNull, Func argumentsFactory) => from m in typeof(AsyncSuperEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly) where !s_skipMethods.Contains(m.Name, StringComparer.Ordinal) - from t in CreateInlineDatas(m, canBeNull, inlineDataFactory) + from t in CreateArguments(m, canBeNull, argumentsFactory) select t; - private static IEnumerable CreateInlineDatas(MethodInfo methodDefinition, bool canBeNull, Func inlineDataFactory) + private static IEnumerable CreateArguments(MethodInfo methodDefinition, bool canBeNull, Func argumentsFactory) { var method = InstantiateMethod(methodDefinition); var parameters = method.GetParameters().ToList(); @@ -66,9 +68,7 @@ private static IEnumerable CreateInlineDatas(MethodInfo methodDefiniti return from param in parameters where IsReferenceType(param) && ParameterCanBeNull(param) == canBeNull let arguments = parameters.Select(p => p == param ? null : CreateInstance(p.ParameterType)).ToArray() - let InlineData = inlineDataFactory(method, arguments, param.Name!) - let testName = GetTestName(methodDefinition, param) - select new object[] { InlineData }; + select argumentsFactory(method, arguments, param.Name!); } private static string GetTestName(MethodInfo definition, ParameterInfo parameter) => diff --git a/Tests/SuperLinq.Async.Test/OnErrorResumeNextTest.cs b/Tests/SuperLinq.Async.Tests/OnErrorResumeNextTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/OnErrorResumeNextTest.cs rename to Tests/SuperLinq.Async.Tests/OnErrorResumeNextTest.cs index 9ffac42e0..403fe12e6 100644 --- a/Tests/SuperLinq.Async.Test/OnErrorResumeNextTest.cs +++ b/Tests/SuperLinq.Async.Tests/OnErrorResumeNextTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class OnErrorResumeNextTest { - [Fact] + [Test] public void OnErrorResumeNextIsLazy() { _ = new AsyncBreakingSequence().OnErrorResumeNext(new AsyncBreakingSequence()); @@ -11,7 +11,7 @@ public void OnErrorResumeNextIsLazy() _ = new AsyncBreakingSequence>().OnErrorResumeNext(); } - [Fact] + [Test] public async Task OnErrorResumeNextMultipleSequencesNoExceptions() { await using var ts1 = Enumerable.Range(1, 10).AsTestingSequence(); @@ -29,12 +29,12 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(1, 10))); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] - [InlineData(5)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] + [Arguments(5)] public async Task OnErrorResumeNextMultipleSequencesWithNoExceptionOnSequence(int sequenceNumber) { var cnt = 1; diff --git a/Tests/SuperLinq.Async.Test/OrderByTest.cs b/Tests/SuperLinq.Async.Tests/OrderByTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/OrderByTest.cs rename to Tests/SuperLinq.Async.Tests/OrderByTest.cs index bb2d62d68..e044e16a2 100644 --- a/Tests/SuperLinq.Async.Test/OrderByTest.cs +++ b/Tests/SuperLinq.Async.Tests/OrderByTest.cs @@ -1,6 +1,6 @@ using System.Globalization; -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the OrderBy/ThenBy operators @@ -10,7 +10,7 @@ public sealed class OrderByTests /// /// Verify that OrderBy preserves the selector /// - [Fact] + [Test] public async Task TestOrderBySelectorPreserved() { var sequenceAscending = AsyncEnumerable.Range(1, 100); @@ -30,7 +30,7 @@ public async Task TestOrderBySelectorPreserved() /// /// Verify that OrderBy preserves the comparer /// - [Fact] + [Test] public async Task TestOrderByComparerPreserved() { var sequence = AsyncEnumerable.Range(1, 100); @@ -60,7 +60,7 @@ public async Task TestOrderByComparerPreserved() /// /// Verify that ThenBy preserves the selector /// - [Fact] + [Test] public async Task TestThenBySelectorPreserved() { var sequence = AsyncSeq( @@ -93,7 +93,7 @@ public async Task TestThenBySelectorPreserved() /// /// Verify that ThenBy preserves the comparer /// - [Fact] + [Test] public async Task TestThenByComparerPreserved() { var sequence = AsyncSeq( diff --git a/Tests/SuperLinq.Async.Test/PadStartTest.cs b/Tests/SuperLinq.Async.Tests/PadStartTest.cs similarity index 53% rename from Tests/SuperLinq.Async.Test/PadStartTest.cs rename to Tests/SuperLinq.Async.Tests/PadStartTest.cs index cdd7f4777..dc2583087 100644 --- a/Tests/SuperLinq.Async.Test/PadStartTest.cs +++ b/Tests/SuperLinq.Async.Tests/PadStartTest.cs @@ -1,17 +1,17 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PadStartTest { // PadStart(source, width) - [Fact] + [Test] public void PadStartWithNegativeWidth() { _ = Assert.Throws(() => AsyncSeq().PadStart(-1)); } - [Fact] + [Test] public void PadStartIsLazy() { _ = new AsyncBreakingSequence().PadStart(0); @@ -19,11 +19,11 @@ public void PadStartIsLazy() public sealed class PadStartWithDefaultPadding { - [Theory] - [InlineData(new[] { 123, 456, 789 }, 2, new[] { 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 3, new[] { 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 4, new[] { 0, 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 5, new[] { 0, 0, 123, 456, 789 })] + [Test] + [Arguments(new[] { 123, 456, 789 }, 2, new[] { 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 3, new[] { 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 4, new[] { 0, 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 5, new[] { 0, 0, 123, 456, 789 })] public async Task ValueTypeElements(ICollection source, int width, IEnumerable expected) { await using var xs = source.AsTestingSequence(); @@ -32,11 +32,11 @@ await xs .AssertSequenceEqual(expected); } - [Theory] - [InlineData(new[] { "foo", "bar", "baz" }, 2, new[] { "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 3, new[] { "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 4, new[] { null, "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 5, new[] { null, null, "foo", "bar", "baz" })] + [Test] + [Arguments(new[] { "foo", "bar", "baz" }, 2, new[] { "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 3, new[] { "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 4, new[] { null, "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 5, new[] { null, null, "foo", "bar", "baz" })] public async Task ReferenceTypeElements(ICollection source, int width, IEnumerable expected) { await using var xs = source.AsTestingSequence(); @@ -48,14 +48,14 @@ await xs // PadStart(source, width, padding) - [Fact] + [Test] public void PadStartWithPaddingWithNegativeWidth() { _ = Assert.Throws( () => new AsyncBreakingSequence().PadStart(-1, 1)); } - [Fact] + [Test] public void PadStartWithPaddingIsLazy() { _ = new AsyncBreakingSequence().PadStart(0, -1); @@ -63,11 +63,11 @@ public void PadStartWithPaddingIsLazy() public sealed class PadStartWithPadding { - [Theory] - [InlineData(new[] { 123, 456, 789 }, 2, new[] { 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 3, new[] { 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 4, new[] { -1, 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 5, new[] { -1, -1, 123, 456, 789 })] + [Test] + [Arguments(new[] { 123, 456, 789 }, 2, new[] { 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 3, new[] { 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 4, new[] { -1, 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 5, new[] { -1, -1, 123, 456, 789 })] public async Task ValueTypeElements(ICollection source, int width, IEnumerable expected) { await using var xs = source.AsTestingSequence(); @@ -76,11 +76,11 @@ await xs .AssertSequenceEqual(expected); } - [Theory] - [InlineData(new[] { "foo", "bar", "baz" }, 2, new[] { "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 3, new[] { "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 4, new[] { "", "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 5, new[] { "", "", "foo", "bar", "baz" })] + [Test] + [Arguments(new[] { "foo", "bar", "baz" }, 2, new[] { "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 3, new[] { "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 4, new[] { "", "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 5, new[] { "", "", "foo", "bar", "baz" })] public async Task ReferenceTypeElements(ICollection source, int width, IEnumerable expected) { await using var xs = source.AsTestingSequence(); @@ -92,14 +92,14 @@ await xs // PadStart(source, width, paddingSelector) - [Fact] + [Test] public void PadStartWithSelectorWithNegativeWidth() { _ = Assert.Throws( () => new AsyncBreakingSequence().PadStart(-1, SuperEnumerable.Identity)); } - [Fact] + [Test] public void PadStartWithSelectorIsLazy() { _ = new AsyncBreakingSequence().PadStart(0, BreakingFunc.Of()); @@ -107,13 +107,13 @@ public void PadStartWithSelectorIsLazy() public sealed class PadStartWithSelector { - [Theory] - [InlineData(new[] { 123, 456, 789 }, 2, new[] { 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 3, new[] { 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 4, new[] { 0, 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 5, new[] { 0, -1, 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 6, new[] { 0, -1, -4, 123, 456, 789 })] - [InlineData(new[] { 123, 456, 789 }, 7, new[] { 0, -1, -4, -9, 123, 456, 789 })] + [Test] + [Arguments(new[] { 123, 456, 789 }, 2, new[] { 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 3, new[] { 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 4, new[] { 0, 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 5, new[] { 0, -1, 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 6, new[] { 0, -1, -4, 123, 456, 789 })] + [Arguments(new[] { 123, 456, 789 }, 7, new[] { 0, -1, -4, -9, 123, 456, 789 })] public async Task ValueTypeElements(ICollection source, int width, IEnumerable expected) { await using var xs = source.AsTestingSequence(); @@ -122,13 +122,13 @@ await xs .AssertSequenceEqual(expected); } - [Theory] - [InlineData(new[] { "foo", "bar", "baz" }, 2, new[] { "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 3, new[] { "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 4, new[] { "+", "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 5, new[] { "+", "++", "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 6, new[] { "+", "++", "+++", "foo", "bar", "baz" })] - [InlineData(new[] { "foo", "bar", "baz" }, 7, new[] { "+", "++", "+++", "++++", "foo", "bar", "baz" })] + [Test] + [Arguments(new[] { "foo", "bar", "baz" }, 2, new[] { "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 3, new[] { "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 4, new[] { "+", "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 5, new[] { "+", "++", "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 6, new[] { "+", "++", "+++", "foo", "bar", "baz" })] + [Arguments(new[] { "foo", "bar", "baz" }, 7, new[] { "+", "++", "+++", "++++", "foo", "bar", "baz" })] public async Task ReferenceTypeElements(ICollection source, int width, IEnumerable expected) { await using var xs = source.AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/PadTest.cs b/Tests/SuperLinq.Async.Tests/PadTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/PadTest.cs rename to Tests/SuperLinq.Async.Tests/PadTest.cs index aaa1dd403..1dabf62ab 100644 --- a/Tests/SuperLinq.Async.Test/PadTest.cs +++ b/Tests/SuperLinq.Async.Tests/PadTest.cs @@ -1,21 +1,21 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PadTest { - [Fact] + [Test] public void PadNegativeWidth() { _ = Assert.Throws(() => AsyncSeq().Pad(-1)); } - [Fact] + [Test] public void PadIsLazy() { _ = new AsyncBreakingSequence().Pad(0); } - [Fact] + [Test] public void PadWithFillerIsLazy() { _ = new AsyncBreakingSequence().Pad(0, new object()); @@ -23,7 +23,7 @@ public void PadWithFillerIsLazy() public sealed class ValueTypeElements { - [Fact] + [Test] public async Task PadWideSourceSequence() { await using var sequence = TestingSequence.Of(123, 456, 789); @@ -31,7 +31,7 @@ public async Task PadWideSourceSequence() await result.AssertSequenceEqual(123, 456, 789); } - [Fact] + [Test] public async Task PadEqualSourceSequence() { await using var sequence = TestingSequence.Of(123, 456, 789); @@ -39,7 +39,7 @@ public async Task PadEqualSourceSequence() await result.AssertSequenceEqual(123, 456, 789); } - [Fact] + [Test] public async Task PadNarrowSourceSequenceWithDefaultPadding() { await using var sequence = TestingSequence.Of(123, 456, 789); @@ -47,7 +47,7 @@ public async Task PadNarrowSourceSequenceWithDefaultPadding() await result.AssertSequenceEqual(123, 456, 789, 0, 0); } - [Fact] + [Test] public async Task PadNarrowSourceSequenceWithNonDefaultPadding() { await using var sequence = TestingSequence.Of(123, 456, 789); @@ -55,7 +55,7 @@ public async Task PadNarrowSourceSequenceWithNonDefaultPadding() await result.AssertSequenceEqual(123, 456, 789, -1, -1); } - [Fact] + [Test] public async Task PadNarrowSourceSequenceWithDynamicPadding() { var result = "hello".ToCharArray().ToAsyncEnumerable().Pad(15, i => i % 2 == 0 ? '+' : '-'); @@ -65,7 +65,7 @@ public async Task PadNarrowSourceSequenceWithDynamicPadding() public sealed class ReferenceTypeElements { - [Fact] + [Test] public async Task PadWideSourceSequence() { await using var sequence = TestingSequence.Of("foo", "bar", "baz"); @@ -73,7 +73,7 @@ public async Task PadWideSourceSequence() await result.AssertSequenceEqual("foo", "bar", "baz"); } - [Fact] + [Test] public async Task PadEqualSourceSequence() { await using var sequence = TestingSequence.Of("foo", "bar", "baz"); @@ -81,7 +81,7 @@ public async Task PadEqualSourceSequence() await result.AssertSequenceEqual("foo", "bar", "baz"); } - [Fact] + [Test] public async Task PadNarrowSourceSequenceWithDefaultPadding() { await using var sequence = TestingSequence.Of("foo", "bar", "baz"); @@ -89,7 +89,7 @@ public async Task PadNarrowSourceSequenceWithDefaultPadding() await result.AssertSequenceEqual("foo", "bar", "baz", null, null); } - [Fact] + [Test] public async Task PadNarrowSourceSequenceWithNonDefaultPadding() { await using var sequence = TestingSequence.Of("foo", "bar", "baz"); diff --git a/Tests/SuperLinq.Async.Test/PartialSortByTest.cs b/Tests/SuperLinq.Async.Tests/PartialSortByTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/PartialSortByTest.cs rename to Tests/SuperLinq.Async.Tests/PartialSortByTest.cs index fe6bd9df1..e612e31f5 100644 --- a/Tests/SuperLinq.Async.Test/PartialSortByTest.cs +++ b/Tests/SuperLinq.Async.Tests/PartialSortByTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PartialSortByTests { - [Fact] + [Test] public async Task PartialSortBy() { var ns = SuperEnumerable.RandomDouble() @@ -16,7 +16,7 @@ await sequence .AssertSequenceEqual(ns.Take(5)); } - [Fact] + [Test] public async Task PartialSortWithOrder() { var ns = SuperEnumerable.RandomDouble() @@ -35,7 +35,7 @@ await sequence .AssertSequenceEqual(ns.Reverse().Take(5)); } - [Fact] + [Test] public async Task PartialSortWithComparer() { await using var alphabet = Enumerable.Range(0, 26) @@ -49,13 +49,13 @@ await alphabet .AssertSequenceEqual('A', 'C', 'E', 'G', 'I'); } - [Fact] + [Test] public void PartialSortByIsLazy() { _ = new AsyncBreakingSequence().PartialSortBy(1, BreakingFunc.Of()); } - [Fact] + [Test] public async Task PartialSortByIsStable() { await using var list = new[] diff --git a/Tests/SuperLinq.Async.Test/PartialSortTest.cs b/Tests/SuperLinq.Async.Tests/PartialSortTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/PartialSortTest.cs rename to Tests/SuperLinq.Async.Tests/PartialSortTest.cs index be0cbbf78..0c0160548 100644 --- a/Tests/SuperLinq.Async.Test/PartialSortTest.cs +++ b/Tests/SuperLinq.Async.Tests/PartialSortTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PartialSortTests { - [Fact] + [Test] public async Task PartialSort() { await using var sequence = Enumerable.Range(1, 10) @@ -15,7 +15,7 @@ await sequence .AssertSequenceEqual(Enumerable.Range(0, 5)); } - [Fact] + [Test] public async Task PartialSortWithOrder() { await using var sequence = Enumerable.Range(1, 10) @@ -31,7 +31,7 @@ await sequence .AssertSequenceEqual(Enumerable.Range(6, 5).Reverse()); } - [Fact] + [Test] public async Task PartialSortWithDuplicates() { await using var sequence = Enumerable.Range(1, 10) @@ -44,7 +44,7 @@ await sequence .AssertSequenceEqual(1, 2, 3, 3, 3); } - [Fact] + [Test] public async Task PartialSortWithComparer() { await using var sequence = Enumerable.Range(0, 26) @@ -57,13 +57,13 @@ await sequence .AssertSequenceEqual('A', 'C', 'E', 'G', 'I'); } - [Fact] + [Test] public void PartialSortIsLazy() { _ = new AsyncBreakingSequence().PartialSort(1); } - [Fact] + [Test] public async Task PartialSortIsStable() { await using var list = new[] diff --git a/Tests/SuperLinq.Async.Test/PartitionTest.cs b/Tests/SuperLinq.Async.Tests/PartitionTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/PartitionTest.cs rename to Tests/SuperLinq.Async.Tests/PartitionTest.cs index c68a05ba8..8305c5185 100644 --- a/Tests/SuperLinq.Async.Test/PartitionTest.cs +++ b/Tests/SuperLinq.Async.Tests/PartitionTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PartitionTest { - [Fact] + [Test] public async Task Partition() { await using var sequence = Enumerable.Range(0, 10).AsTestingSequence(); @@ -13,7 +13,7 @@ public async Task Partition() odds.AssertSequenceEqual(1, 3, 5, 7, 9); } - [Fact] + [Test] public async Task PartitionWithEmptySequence() { await using var sequence = Enumerable.Empty().AsTestingSequence(); @@ -24,7 +24,7 @@ public async Task PartitionWithEmptySequence() odds.AssertSequenceEqual(); } - [Fact] + [Test] public async Task PartitionWithResultSelector() { await using var sequence = Enumerable.Range(0, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/PreScanTest.cs b/Tests/SuperLinq.Async.Tests/PreScanTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/PreScanTest.cs rename to Tests/SuperLinq.Async.Tests/PreScanTest.cs index 3349f9917..b32dfe58d 100644 --- a/Tests/SuperLinq.Async.Test/PreScanTest.cs +++ b/Tests/SuperLinq.Async.Tests/PreScanTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PreScanTest { - [Fact] + [Test] public void PreScanIsLazy() { _ = new AsyncBreakingSequence().PreScan(BreakingFunc.Of(), 0); } - [Fact] + [Test] public async Task PreScanWithEmptySequence() { await using var source = TestingSequence.Of(); @@ -17,7 +17,7 @@ public async Task PreScanWithEmptySequence() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task PreScanWithSingleElement() { await using var source = TestingSequence.Of(111); @@ -26,7 +26,7 @@ public async Task PreScanWithSingleElement() await result.AssertSequenceEqual(999); } - [Fact] + [Test] public async Task PreScanSum() { await using var source = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -35,7 +35,7 @@ public async Task PreScanSum() await result.AssertSequenceEqual(0, 1, 3, 6, 10, 15, 21, 28, 36, 45); } - [Fact] + [Test] public async Task PreScanMul() { await using var source = TestingSequence.Of(1, 2, 3); @@ -44,7 +44,7 @@ public async Task PreScanMul() await result.AssertSequenceEqual(1, 1, 2); } - [Fact] + [Test] public async Task PreScanFuncIsNotInvokedUnnecessarily() { await using var source = Enumerable.Range(1, 3).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/PublishTest.cs b/Tests/SuperLinq.Async.Tests/PublishTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/PublishTest.cs rename to Tests/SuperLinq.Async.Tests/PublishTest.cs index 955ff20ef..a58d77c08 100644 --- a/Tests/SuperLinq.Async.Test/PublishTest.cs +++ b/Tests/SuperLinq.Async.Tests/PublishTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class PublishTest { - [Fact] + [Test] public void PublishIsLazy() { _ = new AsyncBreakingSequence().Publish(); } - [Fact] + [Test] public async Task PublishWithSingleConsumer() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -17,7 +17,7 @@ public async Task PublishWithSingleConsumer() await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public async Task PublishWithMultipleConsumers() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -67,7 +67,7 @@ public async Task PublishWithMultipleConsumers() Assert.Equal(0, result.Count); } - [Fact] + [Test] public async Task PublishWithInnerConsumer() { await using var seq = Enumerable.Range(1, 6).AsTestingSequence(); @@ -94,7 +94,7 @@ public async Task PublishWithInnerConsumer() Assert.Equal(0, result.Count); } - [Fact] + [Test] public async Task PublishWithSequentialPartialConsumers() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -127,7 +127,7 @@ public async Task PublishWithSequentialPartialConsumers() Assert.Equal(0, result.Count); } - [Fact] + [Test] public async Task PublishDisposesAfterSourceIsIteratedEntirely() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -138,7 +138,7 @@ public async Task PublishDisposesAfterSourceIsIteratedEntirely() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public async Task PublishDisposesWithPartialEnumeration() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -151,7 +151,7 @@ public async Task PublishDisposesWithPartialEnumeration() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public async Task PublishRestartsAfterReset() { var starts = 0; @@ -174,7 +174,7 @@ IEnumerable TestSequence() Assert.Equal(2, starts); } - [Fact] + [Test] public async Task PublishThrowsWhenCacheDisposedDuringIteration() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -189,7 +189,7 @@ public async Task PublishThrowsWhenCacheDisposedDuringIteration() async () => await reader.Read()); } - [Fact] + [Test] public async Task PublishThrowsWhenResetDuringIteration() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -205,7 +205,7 @@ public async Task PublishThrowsWhenResetDuringIteration() Assert.Equal("Buffer reset during iteration.", ex.Message); } - [Fact] + [Test] public async Task PublishThrowsWhenGettingIteratorAfterDispose() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -217,7 +217,7 @@ public async Task PublishThrowsWhenGettingIteratorAfterDispose() async () => await buffer.Consume()); } - [Fact] + [Test] public async Task PublishThrowsWhenResettingAfterDispose() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -229,7 +229,7 @@ public async Task PublishThrowsWhenResettingAfterDispose() async () => await buffer.Reset()); } - [Fact] + [Test] public async Task PublishRethrowsErrorDuringIterationToAllIteratorsUntilReset() { await using var xs = AsyncSeqExceptionAt(2).AsTestingSequence(maxEnumerations: 2); @@ -256,7 +256,7 @@ public async Task PublishRethrowsErrorDuringIterationToAllIteratorsUntilReset() Assert.Equal(1, await r4.Read()); } - [Fact] + [Test] public async Task PublishRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { await using var seq = new FailingEnumerable().AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Async.Test/RandomTest.cs b/Tests/SuperLinq.Async.Tests/RandomTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/RandomTest.cs rename to Tests/SuperLinq.Async.Tests/RandomTest.cs index f89c7050e..28acf3704 100644 --- a/Tests/SuperLinq.Async.Test/RandomTest.cs +++ b/Tests/SuperLinq.Async.Tests/RandomTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Tests of the various overloads of .Random() @@ -10,7 +10,7 @@ public sealed class RandomTest /// /// Verify that passing a negative maximum value yields an exception /// - [Fact] + [Test] public void TestNegativeMaxValueException() { _ = Assert.Throws(() => @@ -21,7 +21,7 @@ public void TestNegativeMaxValueException() /// Verify that passing lower bound that is greater than the upper bound results /// in an exception. /// - [Fact] + [Test] public void TestMinValueGreaterThanMaxValueException() { _ = Assert.Throws(() => @@ -31,7 +31,7 @@ public void TestMinValueGreaterThanMaxValueException() /// /// Verify that we can produce a valid sequence or random doubles between 0.0 and 1.0 /// - [Fact] + [Test] public async Task TestRandomDouble() { var resultA = AsyncSuperEnumerable.RandomDouble().Take(RandomTrials); @@ -47,7 +47,7 @@ public async Task TestRandomDouble() /// /// Verify that the max constraint is preserved by the sequence generator. /// - [Fact] + [Test] public async Task TestRandomMaxConstraint() { var resultA = AsyncSuperEnumerable.Random(100).Take(RandomTrials); @@ -62,7 +62,7 @@ public async Task TestRandomMaxConstraint() /// /// Verify that the min/max constraints are preserved by the sequence generator. /// - [Fact] + [Test] public async Task TestRandomMinMaxConstraint() { var resultA = AsyncSuperEnumerable.Random(0, 100).Take(RandomTrials); @@ -78,7 +78,7 @@ public async Task TestRandomMinMaxConstraint() /// Evaluate that using a random sequence (with a given generator) /// is equivalent to a for loop accessing the same random generator. /// - [Fact] + [Test] public Task TestRandomEquivalence() { // must use a specific seed to ensure sequences will be identical diff --git a/Tests/SuperLinq.Async.Test/RankTest.cs b/Tests/SuperLinq.Async.Tests/RankTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/RankTest.cs rename to Tests/SuperLinq.Async.Tests/RankTest.cs index 0a44e5372..4b75615b5 100644 --- a/Tests/SuperLinq.Async.Test/RankTest.cs +++ b/Tests/SuperLinq.Async.Tests/RankTest.cs @@ -1,11 +1,11 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class RankTests { /// /// Verify that Rank uses deferred execution /// - [Fact] + [Test] public void TestRankIsLazy() { _ = new AsyncBreakingSequence().Rank(); @@ -15,7 +15,7 @@ public void TestRankIsLazy() /// /// Verify that RankBy uses deferred execution /// - [Fact] + [Test] public void TestRankByIsLazy() { _ = new AsyncBreakingSequence().RankBy(BreakingFunc.Of()); @@ -26,7 +26,7 @@ public void TestRankByIsLazy() /// Verify that calling Rank with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Fact] + [Test] public async Task TestRankNullComparer() { await using var sequence = @@ -44,7 +44,7 @@ public async Task TestRankNullComparer() /// Verify that calling RankBy with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Fact] + [Test] public async Task TestRankByNullComparer() { await using var sequence = @@ -63,7 +63,7 @@ public async Task TestRankByNullComparer() /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Fact] + [Test] public async Task TestRankDescendingSequence() { await using var sequence = @@ -92,7 +92,7 @@ public async Task TestRankDescendingSequence() /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Fact] + [Test] public async Task TestRankByAscendingSeries() { await using var sequence = @@ -120,7 +120,7 @@ public async Task TestRankByAscendingSeries() /// results in a sequence in descending order, using OrderByDirection.Descending /// with the default comparer for the given element. /// - [Fact] + [Test] public async Task TestRankOrderByDescending() { await using var sequence = @@ -142,7 +142,7 @@ await sequence /// /// Verify that the rank of equivalent items in a sequence is the same. /// - [Fact] + [Test] public async Task TestRankGroupedItems() { await using var sequence = @@ -175,7 +175,7 @@ public async Task TestRankGroupedItems() /// /// Verify that the highest rank (that of the largest item) is 1 (not 0). /// - [Fact] + [Test] public async Task TestRankOfHighestItemIsOne() { await using var sequence = @@ -197,7 +197,7 @@ public record Person(string Name, int Age, int ExpectedRank); /// /// Verify that we can rank items by an arbitrary key produced from the item. /// - [Fact] + [Test] public async Task TestRankByKeySelector() { var sequences = new List @@ -248,7 +248,7 @@ public async Task TestRankByKeySelector() /// /// Verify that Rank can use a custom comparer /// - [Fact] + [Test] public async Task TestRankCustomComparer() { var ordinals = Enumerable.Range(1, 10); diff --git a/Tests/SuperLinq.Async.Test/RepeatTest.cs b/Tests/SuperLinq.Async.Tests/RepeatTest.cs similarity index 87% rename from Tests/SuperLinq.Async.Test/RepeatTest.cs rename to Tests/SuperLinq.Async.Tests/RepeatTest.cs index b8fb04666..f9c7136a1 100644 --- a/Tests/SuperLinq.Async.Test/RepeatTest.cs +++ b/Tests/SuperLinq.Async.Tests/RepeatTest.cs @@ -1,11 +1,11 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class RepeatTest { - [Theory] - [InlineData(1)] - [InlineData(10)] - [InlineData(50)] + [Test] + [Arguments(1)] + [Arguments(10)] + [Arguments(50)] public async Task RepeatItemForeverBehavior(int repeats) { var result = AsyncSuperEnumerable.Repeat(42); @@ -16,20 +16,20 @@ public async Task RepeatItemForeverBehavior(int repeats) .AllAsync(x => x == 42)); } - [Fact] + [Test] public void RepeatIsLazy() { _ = new AsyncBreakingSequence().Repeat(4); } - [Fact] + [Test] public void RepeatValidatesArguments() { _ = Assert.Throws("count", () => new AsyncBreakingSequence().Repeat(0)); } - [Fact] + [Test] public async Task RepeatBehavior() { await using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -43,16 +43,16 @@ public async Task RepeatBehavior() await result.AssertSequenceEqual(expected); } - [Fact] + [Test] public void RepeatForeverIsLazy() { _ = new AsyncBreakingSequence().Repeat(); } - [Theory] - [InlineData(1)] - [InlineData(10)] - [InlineData(50)] + [Test] + [Arguments(1)] + [Arguments(10)] + [Arguments(50)] public async Task RepeatForeverBehavior(int repeats) { await using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ReplaceTest.cs b/Tests/SuperLinq.Async.Tests/ReplaceTest.cs similarity index 89% rename from Tests/SuperLinq.Async.Test/ReplaceTest.cs rename to Tests/SuperLinq.Async.Tests/ReplaceTest.cs index 46b343b68..f7ee5ef5f 100644 --- a/Tests/SuperLinq.Async.Test/ReplaceTest.cs +++ b/Tests/SuperLinq.Async.Tests/ReplaceTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ReplaceTest { - [Fact] + [Test] public void ReplaceIsLazy() { _ = new AsyncBreakingSequence().Replace(0, 10); @@ -12,7 +12,7 @@ public void ReplaceIsLazy() _ = new AsyncBreakingSequence().Replace(^0, 10); } - [Fact] + [Test] public async Task ReplaceEmptySequence() { await using var seq = Enumerable.Empty().AsTestingSequence(maxEnumerations: 6); @@ -24,10 +24,11 @@ public async Task ReplaceEmptySequence() await seq.Replace(^10, 10).AssertSequenceEqual(); } - public static IEnumerable Indices() => - Enumerable.Range(0, 10).Select(i => new object[] { i }); + public static IEnumerable Indices() => + Enumerable.Range(0, 10); - [Theory, MemberData(nameof(Indices))] + [Test] + [MethodDataSource(nameof(Indices))] public async Task ReplaceIntIndex(int index) { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -39,7 +40,8 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(index + 2, 9 - index))); } - [Theory, MemberData(nameof(Indices))] + [Test] + [MethodDataSource(nameof(Indices))] public async Task ReplaceStartIndex(int index) { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -51,7 +53,8 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(index + 2, 9 - index))); } - [Theory, MemberData(nameof(Indices))] + [Test] + [MethodDataSource(nameof(Indices))] public async Task ReplaceEndIndex(int index) { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -63,7 +66,7 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(11 - index, index))); } - [Fact] + [Test] public async Task ReplaceIntIndexPastSequenceLength() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -72,7 +75,7 @@ public async Task ReplaceIntIndexPastSequenceLength() await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public async Task ReplaceStartIndexPastSequenceLength() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -81,7 +84,7 @@ public async Task ReplaceStartIndexPastSequenceLength() await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public async Task ReplaceEndIndexPastSequenceLength() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/RetryTest.cs b/Tests/SuperLinq.Async.Tests/RetryTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/RetryTest.cs rename to Tests/SuperLinq.Async.Tests/RetryTest.cs index 3d2420d22..fd4b55edc 100644 --- a/Tests/SuperLinq.Async.Test/RetryTest.cs +++ b/Tests/SuperLinq.Async.Tests/RetryTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class RetryTest { - [Fact] + [Test] public void RetryIsLazy() { _ = new AsyncBreakingSequence().Retry(); } - [Fact] + [Test] public async Task RetryNoExceptions() { await using var ts = Enumerable.Range(1, 10).AsTestingSequence(); @@ -17,7 +17,7 @@ public async Task RetryNoExceptions() await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public async Task RetryWithExceptions() { await using var ts1 = AsyncSeqExceptionAt(2).AsTestingSequence(); @@ -42,13 +42,13 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(1, 10))); } - [Fact] + [Test] public void RetryCountIsLazy() { _ = new AsyncBreakingSequence().Retry(3); } - [Fact] + [Test] public async Task RetryCountNoExceptions() { await using var ts = Enumerable.Range(1, 10).AsTestingSequence(); @@ -57,7 +57,7 @@ public async Task RetryCountNoExceptions() await result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public async Task RetryCountWithExceptionsComplete() { await using var ts1 = AsyncSeqExceptionAt(2).AsTestingSequence(); @@ -82,7 +82,7 @@ await result.AssertSequenceEqual( .Concat(Enumerable.Range(1, 10))); } - [Fact] + [Test] public async Task RetryCountWithExceptionsThrow() { await using var ts1 = AsyncSeqExceptionAt(2).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ReturnTest.cs b/Tests/SuperLinq.Async.Tests/ReturnTest.cs similarity index 81% rename from Tests/SuperLinq.Async.Test/ReturnTest.cs rename to Tests/SuperLinq.Async.Tests/ReturnTest.cs index f669f418f..ba1438d4b 100644 --- a/Tests/SuperLinq.Async.Test/ReturnTest.cs +++ b/Tests/SuperLinq.Async.Tests/ReturnTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ReturnTest { - [Fact] + [Test] public async Task TestResultingSequenceContainsSingle() { var item = new object(); diff --git a/Tests/SuperLinq.Async.Test/RightOuterJoin.cs b/Tests/SuperLinq.Async.Tests/RightOuterJoin.cs similarity index 84% rename from Tests/SuperLinq.Async.Test/RightOuterJoin.cs rename to Tests/SuperLinq.Async.Tests/RightOuterJoin.cs index 4b553edae..24a40cf33 100644 --- a/Tests/SuperLinq.Async.Test/RightOuterJoin.cs +++ b/Tests/SuperLinq.Async.Tests/RightOuterJoin.cs @@ -1,6 +1,6 @@ -using static Test.Async.JoinOperation; +using static SuperLinq.Async.Tests.JoinOperation; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class RightOuterJoinTest { @@ -8,7 +8,8 @@ public sealed class RightOuterJoinTest IAsyncEnumerable<(string, string)> left, IAsyncEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Hash, false) => left.RightOuterHashJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -19,10 +20,11 @@ public sealed class RightOuterJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetRightOuterJoins() => - new[] { Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetRightOuterJoins() => + new[] { Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public void RightOuterJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new AsyncBreakingSequence<(string, string)>(); @@ -31,7 +33,8 @@ public void RightOuterJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public async Task RightOuterJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -55,7 +58,8 @@ await result.AssertCollectionEqual( (default, quux)); } - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public async Task RightOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -72,7 +76,8 @@ await result.AssertCollectionEqual( (default, baz)); } - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public async Task RightOuterJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Async.Test/RunLengthEncodeTest.cs b/Tests/SuperLinq.Async.Tests/RunLengthEncodeTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/RunLengthEncodeTest.cs rename to Tests/SuperLinq.Async.Tests/RunLengthEncodeTest.cs index a19f841ed..1fb4c7afa 100644 --- a/Tests/SuperLinq.Async.Test/RunLengthEncodeTest.cs +++ b/Tests/SuperLinq.Async.Tests/RunLengthEncodeTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the RunLengthEncode() operator @@ -8,7 +8,7 @@ public sealed class RunLengthEncodeTests /// /// Verify that the RunLengthEncode() methods behave in a lazy manner. /// - [Fact] + [Test] public void TestRunLengthEncodeIsLazy() { _ = new AsyncBreakingSequence().RunLengthEncode(); @@ -18,7 +18,7 @@ public void TestRunLengthEncodeIsLazy() /// /// Verify that run-length encoding an empty sequence results in an empty sequence. /// - [Fact] + [Test] public async Task TestRunLengthEncodeEmptySequence() { await using var sequence = TestingSequence.Of(); @@ -30,7 +30,7 @@ public async Task TestRunLengthEncodeEmptySequence() /// /// Verify that run-length encoding correctly accepts and uses custom equality comparers. /// - [Fact] + [Test] public async Task TestRunLengthEncodeCustomComparer() { await using var sequence = TestingSequence.Of("a", "A", "a", "b", "b", "B", "B"); @@ -48,7 +48,7 @@ await result /// /// Verify that run-length encoding a known sequence produced a correct result. /// - [Fact] + [Test] public async Task TestRunLengthEncodeResults() { await using var sequence = TestingSequence.Of(1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6); @@ -61,7 +61,7 @@ await result.AssertSequenceEqual( /// /// Verify that run-length encoding a sequence with no runs produces a correct result. /// - [Fact] + [Test] public async Task TestRunLengthEncodeNoRuns() { await using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -75,7 +75,7 @@ await result.AssertSequenceEqual( /// Verify that run-length encoding a sequence consisting of a single repeated value /// produces a correct result. /// - [Fact] + [Test] public async Task TestRunLengthEncodeOneRun() { await using var sequence = Enumerable.Repeat('q', 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ScanByTest.cs b/Tests/SuperLinq.Async.Tests/ScanByTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/ScanByTest.cs rename to Tests/SuperLinq.Async.Tests/ScanByTest.cs index e67aefb7a..20502ae1a 100644 --- a/Tests/SuperLinq.Async.Test/ScanByTest.cs +++ b/Tests/SuperLinq.Async.Tests/ScanByTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ScanByTest { - [Fact] + [Test] public void ScanByIsLazy() { _ = new AsyncBreakingSequence().ScanBy( @@ -11,7 +11,7 @@ public void ScanByIsLazy() BreakingFunc.Of()); } - [Fact] + [Test] public async Task ScanBy() { await using var source = TestingSequence.Of( @@ -41,7 +41,7 @@ await result.AssertSequenceEqual( ('c', ("carlos", 'C', 100))); } - [Fact] + [Test] public async Task ScanByWithSecondOccurenceImmediatelyAfterFirst() { await using var source = "jaffer".AsTestingSequence(); @@ -51,7 +51,7 @@ public async Task ScanByWithSecondOccurenceImmediatelyAfterFirst() await result.AssertSequenceEqual(('j', 0), ('a', 0), ('f', 0), ('f', 1), ('e', 0), ('r', 0)); } - [Fact] + [Test] public async Task ScanByWithEqualityComparer() { await using var source = TestingSequence.Of("a", "B", "c", "A", "b", "A"); @@ -66,7 +66,7 @@ public async Task ScanByWithEqualityComparer() await result.AssertSequenceEqual(("a", 0), ("B", 0), ("c", 0), ("A", 1), ("b", 1), ("A", 2)); } - [Fact] + [Test] public async Task ScanByWithSomeNullKeys() { await using var source = TestingSequence.Of("foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"); @@ -75,7 +75,7 @@ public async Task ScanByWithSomeNullKeys() await result.AssertSequenceEqual(("foo", 0), (null, 0), ("bar", 0), ("baz", 0), (null, 1), (null, 2), ("baz", 1), ("bar", 1), (null, 3), ("foo", 1)); } - [Fact] + [Test] public async Task ScanByWithNullSeed() { await using var source = TestingSequence.Of("foo", null, "bar", null, "baz"); @@ -86,7 +86,7 @@ public async Task ScanByWithNullSeed() await result.AssertSequenceEqual(("foo", nil), (null, nil), ("bar", nil), (null, nil), ("baz", nil)); } - [Fact] + [Test] public async Task ScanByDoesNotIterateUnnecessaryElements() { await using var source = SuperEnumerable diff --git a/Tests/SuperLinq.Async.Test/ScanRightTest.cs b/Tests/SuperLinq.Async.Tests/ScanRightTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/ScanRightTest.cs rename to Tests/SuperLinq.Async.Tests/ScanRightTest.cs index 7d0c6d451..b69a0a986 100644 --- a/Tests/SuperLinq.Async.Test/ScanRightTest.cs +++ b/Tests/SuperLinq.Async.Tests/ScanRightTest.cs @@ -1,12 +1,12 @@ using System.Globalization; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ScanRightTest { // ScanRight(source, func) - [Fact] + [Test] public async Task ScanRightWithEmptySequence() { await using var seq = TestingSequence.Of(); @@ -15,7 +15,7 @@ public async Task ScanRightWithEmptySequence() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task ScanRightFuncIsNotInvokedOnSingleElementSequence() { await using var seq = TestingSequence.Of(1); @@ -24,7 +24,7 @@ public async Task ScanRightFuncIsNotInvokedOnSingleElementSequence() await result.AssertSequenceEqual(1); } - [Fact] + [Test] public async Task ScanRight() { await using var seq = Enumerable.Range(1, 5).AsTestingSequence(); @@ -37,7 +37,7 @@ await result.AssertSequenceEqual( "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5"); } - [Fact] + [Test] public void ScanRightIsLazy() { _ = new AsyncBreakingSequence().ScanRight(BreakingFunc.Of()); @@ -45,10 +45,10 @@ public void ScanRightIsLazy() // ScanRight(source, seed, func) - [Theory] - [InlineData(5)] - [InlineData("c")] - [InlineData(true)] + [Test] + [Arguments(5)] + [Arguments("c")] + [Arguments(true)] public async Task ScanRightSeedWithEmptySequence(object defaultValue) { await using var seq = TestingSequence.Of(); @@ -57,7 +57,7 @@ public async Task ScanRightSeedWithEmptySequence(object defaultValue) await result.AssertSequenceEqual(defaultValue); } - [Fact] + [Test] public async Task ScanRightSeedFuncIsNotInvokedOnEmptySequence() { await using var seq = TestingSequence.Of(); @@ -66,7 +66,7 @@ public async Task ScanRightSeedFuncIsNotInvokedOnEmptySequence() await result.AssertSequenceEqual(1); } - [Fact] + [Test] public async Task ScanRightSeed() { await using var seq = Enumerable.Range(1, 4).AsTestingSequence(); @@ -78,7 +78,7 @@ await result.AssertSequenceEqual( "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5"); } - [Fact] + [Test] public void ScanRightSeedIsLazy() { _ = new AsyncBreakingSequence().ScanRight("", BreakingFunc.Of()); diff --git a/Tests/SuperLinq.Async.Test/ScanTest.cs b/Tests/SuperLinq.Async.Tests/ScanTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/ScanTest.cs rename to Tests/SuperLinq.Async.Tests/ScanTest.cs index 5872d368a..446187e89 100644 --- a/Tests/SuperLinq.Async.Test/ScanTest.cs +++ b/Tests/SuperLinq.Async.Tests/ScanTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ScanTest { - [Fact] + [Test] public async Task ScanEmpty() { await using var seq = TestingSequence.Of(); @@ -11,7 +11,7 @@ public async Task ScanEmpty() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task ScanSum() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -20,13 +20,13 @@ public async Task ScanSum() await result.AssertSequenceEqual(1, 3, 6, 10, 15, 21, 28, 36, 45, 55); } - [Fact] + [Test] public void ScanIsLazy() { _ = new AsyncBreakingSequence().Scan(BreakingFunc.Of()); } - [Fact] + [Test] public async Task ScanDoesNotIterateExtra() { await using var seq = AsyncSeqExceptionAt(4).AsTestingSequence(maxEnumerations: 2); @@ -38,7 +38,7 @@ public async Task ScanDoesNotIterateExtra() await result.Take(3).AssertSequenceEqual(1, 3, 6); } - [Fact] + [Test] public async Task SeededScanEmpty() { await using var seq = TestingSequence.Of(); @@ -47,7 +47,7 @@ public async Task SeededScanEmpty() Assert.Equal(-1, await result.SingleAsync()); } - [Fact] + [Test] public async Task SeededScanSum() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -56,14 +56,14 @@ public async Task SeededScanSum() await result.AssertSequenceEqual(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55); } - [Fact] + [Test] public void SeededScanIsLazy() { _ = new AsyncBreakingSequence().Scan(seed: null, BreakingFunc.Of()); } - [Fact] + [Test] public async Task SeededScanDoesNotIterateExtra() { await using var seq = AsyncSeqExceptionAt(4).AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Async.Test/SegmentTest.cs b/Tests/SuperLinq.Async.Tests/SegmentTest.cs similarity index 79% rename from Tests/SuperLinq.Async.Test/SegmentTest.cs rename to Tests/SuperLinq.Async.Tests/SegmentTest.cs index f003bb9c6..c520bd655 100644 --- a/Tests/SuperLinq.Async.Test/SegmentTest.cs +++ b/Tests/SuperLinq.Async.Tests/SegmentTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the Segment operator @@ -8,7 +8,7 @@ public sealed class SegmentTests /// /// Verify that the Segment operator behaves in a lazy manner /// - [Fact] + [Test] public void TestSegmentIsLazy() { _ = new AsyncBreakingSequence().Segment(BreakingFunc.Of()); @@ -19,7 +19,7 @@ public void TestSegmentIsLazy() /// /// Verify that segmenting a sequence into a single sequence results in the original sequence. /// - [Fact] + [Test] public async Task TestIdentitySegment() { await using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); @@ -32,7 +32,7 @@ public async Task TestIdentitySegment() /// /// Verify that segmenting an empty sequence results in an empty sequence of segments. /// - [Fact] + [Test] public async Task TestEmptySequence() { await using var sequence = AsyncEnumerable.Repeat(-1, 0).AsTestingSequence(); @@ -43,7 +43,7 @@ public async Task TestEmptySequence() /// /// Verify that the segments returned can be enumerated more than once. /// - [Fact] + [Test] public async Task TestSegmentIsIdempotent() { await using var sequence = Enumerable.Repeat(-1, 10).AsTestingSequence(); @@ -60,7 +60,7 @@ public async Task TestSegmentIsIdempotent() /// Verify that the first segment is never empty. By definition, segmentation /// begins with the second element in the source sequence. /// - [Fact] + [Test] public async Task TestFirstSegmentNeverEmpty() { await using (var sequence = Enumerable.Repeat(-1, 10).AsTestingSequence()) @@ -76,7 +76,7 @@ public async Task TestFirstSegmentNeverEmpty() /// /// Verify invariant that segmentation begins with second element of source sequence. /// - [Fact] + [Test] public async Task TestSegmentationStartsWithSecondItem() { await using (var sequence = TestingSequence.Of(0)) @@ -92,7 +92,7 @@ public async Task TestSegmentationStartsWithSecondItem() /// /// Verify we can segment a source sequence by it's zero-based index /// - [Fact] + [Test] public async Task VerifyCanSegmentByIndex() { await using var sequence = Enumerable.Repeat(1, 100) @@ -108,7 +108,7 @@ public async Task VerifyCanSegmentByIndex() /// /// Verify that we can segment a source sequence by the change in adjacent items /// - [Fact] + [Test] public async Task VerifyCanSegmentByPrevious() { var sequence = Enumerable.Range(1, 3) @@ -123,24 +123,17 @@ public async Task VerifyCanSegmentByPrevious() Assert.True(result.All(s => s.Count == 5)); } - public static IEnumerable TestData { get; } = - from e in new[] - { - // input sequence is empty - new { Source = AsyncSeq(), Expected = AsyncSeq>() }, - // input sequence contains only new segment start - new { Source = AsyncSeq(0, 3, 6), Expected = AsyncSeq(Seq(0), Seq(3), Seq(6)) }, - // input sequence do not contains new segment start - new { Source = AsyncSeq(1, 2, 4, 5), Expected = AsyncSeq(Seq(1, 2, 4, 5)) }, - // input sequence start with a segment start - new { Source = AsyncSeq(0, 1, 2, 3, 4, 5), Expected = AsyncSeq(Seq(0, 1, 2), Seq(3, 4, 5)) }, - // input sequence do not start with a segment start - new { Source = AsyncSeq(1, 2, 3, 4, 5), Expected = AsyncSeq(Seq(1, 2), Seq(3, 4, 5)) }, - } - select new object[] { e.Source, e.Expected }; - - [Theory] - [MemberData(nameof(TestData))] + public static IEnumerable<(IEnumerable source, IAsyncEnumerable> expected)> TestData() => + [ + ([], AsyncSeq>() ), + ([0, 3, 6], AsyncSeq(Seq(0), Seq(3), Seq(6)) ), + ([1, 2, 4, 5], AsyncSeq(Seq(1, 2, 4, 5)) ), + ([0, 1, 2, 3, 4, 5], AsyncSeq(Seq(0, 1, 2), Seq(3, 4, 5))), + ([1, 2, 3, 4, 5], AsyncSeq(Seq(1, 2), Seq(3, 4, 5)) ), + ]; + + [Test] + [MethodDataSource(nameof(TestData))] public async Task TestSegment(IEnumerable source, IAsyncEnumerable> expected) { await using var xs = source.AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/SequenceReader.cs b/Tests/SuperLinq.Async.Tests/SequenceReader.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/SequenceReader.cs rename to Tests/SuperLinq.Async.Tests/SequenceReader.cs index 50c5148b3..992c177b2 100644 --- a/Tests/SuperLinq.Async.Test/SequenceReader.cs +++ b/Tests/SuperLinq.Async.Tests/SequenceReader.cs @@ -1,6 +1,6 @@ using System.Diagnostics.CodeAnalysis; -namespace Test.Async; +namespace SuperLinq.Async.Tests; internal static class SequenceReader { diff --git a/Tests/SuperLinq.Async.Test/SequenceTest.cs b/Tests/SuperLinq.Async.Tests/SequenceTest.cs similarity index 58% rename from Tests/SuperLinq.Async.Test/SequenceTest.cs rename to Tests/SuperLinq.Async.Tests/SequenceTest.cs index a47304321..5e11e0fd1 100644 --- a/Tests/SuperLinq.Async.Test/SequenceTest.cs +++ b/Tests/SuperLinq.Async.Tests/SequenceTest.cs @@ -1,27 +1,27 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class SequenceTest { - [Theory] - [InlineData(65600, 65536, 65536)] - [InlineData(0, -1, 2)] - [InlineData(-65600, 65536, -65536)] - [InlineData(int.MaxValue - 1, 2, 2)] + [Test] + [Arguments(65600, 65536, 65536)] + [Arguments(0, -1, 2)] + [Arguments(-65600, 65536, -65536)] + [Arguments(int.MaxValue - 1, 2, 2)] public void RangeThrowsOutOfRange(int start, int count, int step) { _ = Assert.Throws(() => AsyncSuperEnumerable.Range(start, count, step)); } - [Theory] - [InlineData(1, 2, 3)] - [InlineData(1, 2, -3)] - [InlineData(-32, 10, 30)] - [InlineData(32, 10, -30)] - [InlineData(-32, 10, 0)] - [InlineData(32, 10, -0)] - [InlineData(10, 0, 12)] - [InlineData(-10, 0, 12)] + [Test] + [Arguments(1, 2, 3)] + [Arguments(1, 2, -3)] + [Arguments(-32, 10, 30)] + [Arguments(32, 10, -30)] + [Arguments(-32, 10, 0)] + [Arguments(32, 10, -0)] + [Arguments(10, 0, 12)] + [Arguments(-10, 0, 12)] public Task Range(int start, int count, int step) { var result = AsyncSuperEnumerable.Range(start, count, step); @@ -31,12 +31,12 @@ public Task Range(int start, int count, int step) return result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(-10, -4)] - [InlineData(-1, 5)] - [InlineData(1, 10)] - [InlineData(30, 55)] - [InlineData(27, 172)] + [Test] + [Arguments(-10, -4)] + [Arguments(-1, 5)] + [Arguments(1, 10)] + [Arguments(30, 55)] + [Arguments(27, 172)] public Task SequenceWithAscendingRange(int start, int stop) { var result = AsyncSuperEnumerable.Sequence(start, stop); @@ -45,12 +45,12 @@ public Task SequenceWithAscendingRange(int start, int stop) return result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(-4, -10)] - [InlineData(5, -1)] - [InlineData(10, 1)] - [InlineData(55, 30)] - [InlineData(172, 27)] + [Test] + [Arguments(-4, -10)] + [Arguments(5, -1)] + [Arguments(10, 1)] + [Arguments(55, 30)] + [Arguments(172, 27)] public Task SequenceWithDescendingRange(int start, int stop) { var result = AsyncSuperEnumerable.Sequence(start, stop); @@ -59,12 +59,12 @@ public Task SequenceWithDescendingRange(int start, int stop) return result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(-10, -4, 2)] - [InlineData(-1, 5, 3)] - [InlineData(1, 10, 1)] - [InlineData(30, 55, 4)] - [InlineData(27, 172, 9)] + [Test] + [Arguments(-10, -4, 2)] + [Arguments(-1, 5, 3)] + [Arguments(1, 10, 1)] + [Arguments(30, 55, 4)] + [Arguments(27, 172, 9)] public Task SequenceWithAscendingRangeAscendingStep(int start, int stop, int step) { var result = AsyncSuperEnumerable.Sequence(start, stop, step); @@ -73,12 +73,12 @@ public Task SequenceWithAscendingRangeAscendingStep(int start, int stop, int ste return result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(-10, -4, -2)] - [InlineData(-1, 5, -3)] - [InlineData(1, 10, -1)] - [InlineData(30, 55, -4)] - [InlineData(27, 172, -9)] + [Test] + [Arguments(-10, -4, -2)] + [Arguments(-1, 5, -3)] + [Arguments(1, 10, -1)] + [Arguments(30, 55, -4)] + [Arguments(27, 172, -9)] public Task SequenceWithAscendingRangeDescendigStep(int start, int stop, int step) { var result = AsyncSuperEnumerable.Sequence(start, stop, step); @@ -86,12 +86,12 @@ public Task SequenceWithAscendingRangeDescendigStep(int start, int stop, int ste return result.AssertEmpty(); } - [Theory] - [InlineData(-4, -10, 2)] - [InlineData(5, -1, 3)] - [InlineData(10, 1, 1)] - [InlineData(55, 30, 4)] - [InlineData(172, 27, 9)] + [Test] + [Arguments(-4, -10, 2)] + [Arguments(5, -1, 3)] + [Arguments(10, 1, 1)] + [Arguments(55, 30, 4)] + [Arguments(172, 27, 9)] public Task SequenceWithDescendingRangeAscendingStep(int start, int stop, int step) { var result = AsyncSuperEnumerable.Sequence(start, stop, step); @@ -99,12 +99,12 @@ public Task SequenceWithDescendingRangeAscendingStep(int start, int stop, int st return result.AssertEmpty(); } - [Theory] - [InlineData(-4, -10, -2)] - [InlineData(5, -1, -3)] - [InlineData(10, 1, -1)] - [InlineData(55, 30, -4)] - [InlineData(172, 27, -9)] + [Test] + [Arguments(-4, -10, -2)] + [Arguments(5, -1, -3)] + [Arguments(10, 1, -1)] + [Arguments(55, 30, -4)] + [Arguments(172, 27, -9)] public Task SequenceWithDescendingRangeDescendigStep(int start, int stop, int step) { var result = AsyncSuperEnumerable.Sequence(start, stop, step); @@ -113,16 +113,16 @@ public Task SequenceWithDescendingRangeDescendigStep(int start, int stop, int st return result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(int.MaxValue, int.MaxValue, -1)] - [InlineData(int.MaxValue, int.MaxValue, 1)] - [InlineData(int.MaxValue, int.MaxValue, null)] - [InlineData(0, 0, -1)] - [InlineData(0, 0, 1)] - [InlineData(0, 0, null)] - [InlineData(int.MinValue, int.MinValue, -1)] - [InlineData(int.MinValue, int.MinValue, 1)] - [InlineData(int.MinValue, int.MinValue, null)] + [Test] + [Arguments(int.MaxValue, int.MaxValue, -1)] + [Arguments(int.MaxValue, int.MaxValue, 1)] + [Arguments(int.MaxValue, int.MaxValue, null)] + [Arguments(0, 0, -1)] + [Arguments(0, 0, 1)] + [Arguments(0, 0, null)] + [Arguments(int.MinValue, int.MinValue, -1)] + [Arguments(int.MinValue, int.MinValue, 1)] + [Arguments(int.MinValue, int.MinValue, null)] public async Task SequenceWithStartEqualsStop(int start, int stop, int? step) { var result = step.HasValue ? AsyncSuperEnumerable.Sequence(start, stop, step.Value) @@ -131,11 +131,11 @@ public async Task SequenceWithStartEqualsStop(int start, int stop, int? step) Assert.Equal(await result.SingleAsync(), start); } - [Theory] - [InlineData(int.MaxValue - 1, int.MaxValue, 1, 2)] - [InlineData(int.MinValue + 1, int.MinValue, -1, 2)] - [InlineData(0, int.MaxValue, 10000000, (int.MaxValue / 10000000) + 1)] - [InlineData(int.MinValue, int.MaxValue, int.MaxValue, 3)] + [Test] + [Arguments(int.MaxValue - 1, int.MaxValue, 1, 2)] + [Arguments(int.MinValue + 1, int.MinValue, -1, 2)] + [Arguments(0, int.MaxValue, 10000000, (int.MaxValue / 10000000) + 1)] + [Arguments(int.MinValue, int.MaxValue, int.MaxValue, 3)] public async Task SequenceEdgeCases(int start, int stop, int step, int count) { var result = AsyncSuperEnumerable.Sequence(start, stop, step); @@ -143,10 +143,10 @@ public async Task SequenceEdgeCases(int start, int stop, int step, int count) Assert.Equal(await result.CountAsync(), count); } - [Theory] - [InlineData(5, 10)] - [InlineData(int.MaxValue, int.MaxValue)] - [InlineData(int.MinValue, int.MaxValue)] + [Test] + [Arguments(5, 10)] + [Arguments(int.MaxValue, int.MaxValue)] + [Arguments(int.MinValue, int.MaxValue)] public async Task SequenceWithStepZero(int start, int stop) { var result = AsyncSuperEnumerable.Sequence(start, stop, 0); diff --git a/Tests/SuperLinq.Async.Test/ShareTest.cs b/Tests/SuperLinq.Async.Tests/ShareTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/ShareTest.cs rename to Tests/SuperLinq.Async.Tests/ShareTest.cs index f664a0954..d733049d9 100644 --- a/Tests/SuperLinq.Async.Test/ShareTest.cs +++ b/Tests/SuperLinq.Async.Tests/ShareTest.cs @@ -1,16 +1,16 @@ using System.Collections; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ShareTest { - [Fact] + [Test] public void ShareIsLazy() { _ = new AsyncBreakingSequence().Share(); } - [Fact] + [Test] public async Task ShareWithSingleConsumer() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -20,7 +20,7 @@ public async Task ShareWithSingleConsumer() Assert.Equal(0, result.Count); } - [Fact] + [Test] public async Task ShareWithMultipleConsumers() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -45,7 +45,7 @@ public async Task ShareWithMultipleConsumers() await r2.ReadEnd(); } - [Fact] + [Test] public async Task ShareWithInnerConsumer() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -72,7 +72,7 @@ public async Task ShareWithInnerConsumer() await r1.ReadEnd(); } - [Fact] + [Test] public async Task ShareWithSequentialPartialConsumers() { await using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -102,7 +102,7 @@ public async Task ShareWithSequentialPartialConsumers() await r3.ReadEnd(); } - [Fact] + [Test] public async Task ShareDisposesAfterSourceIsIteratedEntirely() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -113,7 +113,7 @@ public async Task ShareDisposesAfterSourceIsIteratedEntirely() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public async Task ShareDisposesWithPartialEnumeration() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -126,7 +126,7 @@ public async Task ShareDisposesWithPartialEnumeration() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public async Task ShareRestartsAfterReset() { var starts = 0; @@ -149,7 +149,7 @@ IEnumerable TestSequence() Assert.Equal(2, starts); } - [Fact] + [Test] public async Task ShareThrowsWhenCacheDisposedDuringIteration() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -164,7 +164,7 @@ public async Task ShareThrowsWhenCacheDisposedDuringIteration() async () => await reader.Read()); } - [Fact] + [Test] public async Task ShareThrowsWhenResetDuringIteration() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -180,7 +180,7 @@ public async Task ShareThrowsWhenResetDuringIteration() Assert.Equal("Buffer reset during iteration.", ex.Message); } - [Fact] + [Test] public async Task ShareThrowsWhenGettingIteratorAfterDispose() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -192,7 +192,7 @@ public async Task ShareThrowsWhenGettingIteratorAfterDispose() async () => await buffer.Consume()); } - [Fact] + [Test] public async Task ShareThrowsWhenResettingAfterDispose() { await using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -204,7 +204,7 @@ public async Task ShareThrowsWhenResettingAfterDispose() async () => await buffer.Reset()); } - [Fact] + [Test] public async Task ShareRethrowsErrorDuringIterationToAllIteratorsUntilReset() { await using var xs = AsyncSeqExceptionAt(2).AsTestingSequence(maxEnumerations: 2); @@ -229,7 +229,7 @@ public async Task ShareRethrowsErrorDuringIterationToAllIteratorsUntilReset() Assert.Equal(1, await r1.Read()); } - [Fact] + [Test] public async Task ShareRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { await using var seq = new FailingEnumerable().AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Async.Test/SkipUntilTest.cs b/Tests/SuperLinq.Async.Tests/SkipUntilTest.cs similarity index 62% rename from Tests/SuperLinq.Async.Test/SkipUntilTest.cs rename to Tests/SuperLinq.Async.Tests/SkipUntilTest.cs index 2fbcc420a..486e3932b 100644 --- a/Tests/SuperLinq.Async.Test/SkipUntilTest.cs +++ b/Tests/SuperLinq.Async.Tests/SkipUntilTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class SkipUntilTest { - [Fact] + [Test] public async Task SkipUntilPredicateNeverFalse() { await using var sequence = AsyncEnumerable.Range(0, 5) @@ -12,7 +12,7 @@ await sequence .AssertSequenceEqual(1, 2, 3, 4); } - [Fact] + [Test] public async Task SkipUntilPredicateNeverTrue() { await using var sequence = AsyncEnumerable.Range(0, 5) @@ -20,7 +20,7 @@ public async Task SkipUntilPredicateNeverTrue() Assert.Empty(await sequence.SkipUntil(x => x == 100).ToListAsync()); } - [Fact] + [Test] public async Task SkipUntilPredicateBecomesTrueHalfWay() { await using var sequence = AsyncEnumerable.Range(0, 5) @@ -30,13 +30,13 @@ await sequence .AssertSequenceEqual(3, 4); } - [Fact] + [Test] public void SkipUntilEvaluatesSourceLazily() { _ = new AsyncBreakingSequence().SkipUntil(x => x.Length == 0); } - [Fact] + [Test] public async Task SkipUntilEvaluatesPredicateLazily() { await using var sequence = AsyncEnumerable.Range(-2, 5) @@ -49,26 +49,31 @@ await sequence .AssertSequenceEqual(0, 1, 2); } - public static IEnumerable TestData { get; } = + public static IEnumerable<(int[] source, int min, int[] expected)> TestData() => [ - [Array.Empty(), 0, Array.Empty()], // empty sequence - [new[] { 0 }, 0, Array.Empty()], // one-item sequence, predicate succeed - [new[] { 0 }, 1, Array.Empty()], // one-item sequence, predicate don't succeed - [new[] { 1, 2, 3 }, 0, new[] { 2, 3 }], // predicate succeed on first item - [new[] { 1, 2, 3 }, 1, new[] { 2, 3 }], - [new[] { 1, 2, 3 }, 2, new[] { 3 }], - [new[] { 1, 2, 3 }, 3, Array.Empty()], // predicate succeed on last item - [new[] { 1, 2, 3 }, 4, Array.Empty()], // predicate never succeed + ([], 0, []), + ([0], 0, []), + ([0], 1, []), + ([1, 2, 3], 0, [2, 3]), + ([1, 2, 3], 1, [2, 3]), + ([1, 2, 3], 2, [3]), + ([1, 2, 3], 3, []), + ([1, 2, 3], 4, []), ]; - [Theory, MemberData(nameof(TestData))] + [Test] + [MethodDataSource(nameof(TestData))] public async Task TestSkipUntil(int[] source, int min, int[] expected) { await using var xs = source .ToAsyncEnumerable() .AsTestingSequence(); - Assert.Equal(expected, await xs - .SkipUntil(v => v >= min) - .ToListAsync()); + + Assert.Equal( + expected, + await xs + .SkipUntil(v => v >= min) + .ToListAsync() + ); } } diff --git a/Tests/SuperLinq.Async.Test/SortedMergeByTest.cs b/Tests/SuperLinq.Async.Tests/SortedMergeByTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/SortedMergeByTest.cs rename to Tests/SuperLinq.Async.Tests/SortedMergeByTest.cs index 7ccf69731..b1ae8fc3e 100644 --- a/Tests/SuperLinq.Async.Test/SortedMergeByTest.cs +++ b/Tests/SuperLinq.Async.Tests/SortedMergeByTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Tests that verify the behavior of the SortedMergeBy operator. @@ -8,7 +8,7 @@ public sealed class SortedMergeByTests /// /// Verify that SortedMergeBy behaves in a lazy manner. /// - [Fact] + [Test] public void TestSortedMergeByIsLazy() { var sequenceA = new AsyncBreakingSequence(); @@ -21,7 +21,7 @@ public void TestSortedMergeByIsLazy() /// Verify that SortedMergeBy disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public async Task TestSortedMergeByDisposesOnError() { await using var sequenceA = TestingSequence.Of(); @@ -34,7 +34,7 @@ public async Task TestSortedMergeByDisposesOnError() /// /// Verify that SortedMergeBy sorts correctly with a comparer. /// - [Fact] + [Test] public async Task TestSortedMergeByComparerNull() { await using var sequenceA = Enumerable.Range(1, 3).AsTestingSequence(); @@ -47,7 +47,7 @@ public async Task TestSortedMergeByComparerNull() /// /// Verify that if otherSequences is empty, SortedMergeBy yields the contents of sequence /// - [Fact] + [Test] public async Task TestSortedMergeByOtherSequencesEmpty() { await using var sequenceA = Enumerable.Range(1, 10).AsTestingSequence(); @@ -59,7 +59,7 @@ public async Task TestSortedMergeByOtherSequencesEmpty() /// /// Verify that if all sequences passed to SortedMergeBy are empty, the result is an empty sequence. /// - [Fact] + [Test] public async Task TestSortedMergeByAllSequencesEmpty() { await using var sequenceA = TestingSequence.Of(); @@ -73,7 +73,7 @@ public async Task TestSortedMergeByAllSequencesEmpty() /// /// Verify that if the primary sequence is empty, SortedMergeBy correctly merges otherSequences /// - [Fact] + [Test] public async Task TestSortedMergeByFirstSequenceEmpty() { await using var sequenceA = TestingSequence.Of(); @@ -87,7 +87,7 @@ public async Task TestSortedMergeByFirstSequenceEmpty() /// /// Verify that SortedMergeBy correctly merges sequences of equal length. /// - [Fact] + [Test] public async Task TestSortedMergeByEqualLengthSequences() { await using var sequenceA = Enumerable.Range(0, 10).Select(x => (x * 3) + 0).AsTestingSequence(); @@ -101,7 +101,7 @@ public async Task TestSortedMergeByEqualLengthSequences() /// /// Verify that sorted merge correctly merges sequences of unequal length. /// - [Fact] + [Test] public async Task TestSortedMergeByUnequalLengthSequences() { await using var sequenceA = Enumerable.Range(0, 30).Select(x => (x * 3) + 0).AsTestingSequence(maxEnumerations: 2); @@ -116,7 +116,7 @@ public async Task TestSortedMergeByUnequalLengthSequences() /// /// Verify that sorted merge correctly uses a custom comparer supplied to it. /// - [Fact] + [Test] public async Task TestSortedMergeByCustomComparer() { await using var sequenceA = new[] { "a", "D", "G", "h", "i", "J", "O", "t", "z" }.AsTestingSequence(maxEnumerations: 2); @@ -135,7 +135,7 @@ public async Task TestSortedMergeByCustomComparer() /// /// Verify that SortedMerge correctly merges sequences with overlapping contents. /// - [Fact] + [Test] public async Task TestSortedMergeOverlappingSequences() { await using var sequenceA = TestingSequence.Of(1, 3, 5, 7, 9, 11); diff --git a/Tests/SuperLinq.Async.Test/SortedMergeTest.cs b/Tests/SuperLinq.Async.Tests/SortedMergeTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/SortedMergeTest.cs rename to Tests/SuperLinq.Async.Tests/SortedMergeTest.cs index 38ddbf64c..5aa2ed5a5 100644 --- a/Tests/SuperLinq.Async.Test/SortedMergeTest.cs +++ b/Tests/SuperLinq.Async.Tests/SortedMergeTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Tests that verify the behavior of the SortedMerge operator. @@ -8,7 +8,7 @@ public sealed class SortedMergeTests /// /// Verify that SortedMerge behaves in a lazy manner. /// - [Fact] + [Test] public void TestSortedMergeIsLazy() { var sequenceA = new AsyncBreakingSequence(); @@ -21,7 +21,7 @@ public void TestSortedMergeIsLazy() /// Verify that SortedMerge disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public async Task TestSortedMergeDisposesOnError() { await using var sequenceA = TestingSequence.Of(); @@ -34,7 +34,7 @@ public async Task TestSortedMergeDisposesOnError() /// /// Verify that SortedMerge sorts correctly with a comparer. /// - [Fact] + [Test] public async Task TestSortedMergeComparerNull() { await using var sequenceA = Enumerable.Range(1, 3).AsTestingSequence(); @@ -47,7 +47,7 @@ public async Task TestSortedMergeComparerNull() /// /// Verify that if otherSequences is empty, SortedMerge yields the contents of sequence /// - [Fact] + [Test] public async Task TestSortedMergeOtherSequencesEmpty() { await using var sequenceA = Enumerable.Range(1, 10).AsTestingSequence(); @@ -59,7 +59,7 @@ public async Task TestSortedMergeOtherSequencesEmpty() /// /// Verify that if all sequences passed to SortedMerge are empty, the result is an empty sequence. /// - [Fact] + [Test] public async Task TestSortedMergeAllSequencesEmpty() { await using var sequenceA = TestingSequence.Of(); @@ -73,7 +73,7 @@ public async Task TestSortedMergeAllSequencesEmpty() /// /// Verify that if the primary sequence is empty, SortedMerge correctly merges otherSequences /// - [Fact] + [Test] public async Task TestSortedMergeFirstSequenceEmpty() { await using var sequenceA = TestingSequence.Of(); @@ -87,7 +87,7 @@ public async Task TestSortedMergeFirstSequenceEmpty() /// /// Verify that SortedMerge correctly merges sequences of equal length. /// - [Fact] + [Test] public async Task TestSortedMergeEqualLengthSequences() { await using var sequenceA = Enumerable.Range(0, 10).Select(x => (x * 3) + 0).AsTestingSequence(); @@ -101,7 +101,7 @@ public async Task TestSortedMergeEqualLengthSequences() /// /// Verify that sorted merge correctly merges sequences of unequal length. /// - [Fact] + [Test] public async Task TestSortedMergeUnequalLengthSequences() { await using var sequenceA = Enumerable.Range(0, 30).Select(x => (x * 3) + 0).AsTestingSequence(maxEnumerations: 2); @@ -116,7 +116,7 @@ public async Task TestSortedMergeUnequalLengthSequences() /// /// Verify that sorted merge correctly uses a custom comparer supplied to it. /// - [Fact] + [Test] public async Task TestSortedMergeCustomComparer() { await using var sequenceA = new[] { "a", "D", "G", "h", "i", "J", "O", "t", "z" }.AsTestingSequence(maxEnumerations: 2); @@ -135,7 +135,7 @@ public async Task TestSortedMergeCustomComparer() /// /// Verify that SortedMerge correctly merges sequences with overlapping contents. /// - [Fact] + [Test] public async Task TestSortedMergeOverlappingSequences() { await using var sequenceA = TestingSequence.Of(1, 3, 5, 7, 9, 11); diff --git a/Tests/SuperLinq.Async.Test/SplitTest.cs b/Tests/SuperLinq.Async.Tests/SplitTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/SplitTest.cs rename to Tests/SuperLinq.Async.Tests/SplitTest.cs index a2ecaee3e..159607554 100644 --- a/Tests/SuperLinq.Async.Test/SplitTest.cs +++ b/Tests/SuperLinq.Async.Tests/SplitTest.cs @@ -1,17 +1,17 @@ using System.Diagnostics.CodeAnalysis; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class SplitTest { - [Fact] + [Test] public void SplitIsLazy() { _ = new AsyncBreakingSequence().Split(1); _ = new AsyncBreakingSequence().Split(1, 2); } - [Fact] + [Test] public async Task SplitWithComparer() { await using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -19,7 +19,7 @@ public async Task SplitWithComparer() await result.AssertSequenceEqual(Enumerable.Range(1, 5).Select(x => new[] { (x * 2) - 1 })); } - [Fact] + [Test] public async Task SplitWithComparerUptoMaxCount() { await using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -27,7 +27,7 @@ public async Task SplitWithComparerUptoMaxCount() await result.AssertSequenceEqual([1], [3], Enumerable.Range(5, 6)); } - [Fact] + [Test] [SuppressMessage("Style", "IDE0305:Simplify collection initialization")] public async Task SplitWithSeparatorAndResultTransformation() { @@ -36,7 +36,7 @@ public async Task SplitWithSeparatorAndResultTransformation() await result.AssertSequenceEqual("the", "quick", "brown", "fox"); } - [Fact] + [Test] [SuppressMessage("Style", "IDE0305:Simplify collection initialization")] public async Task SplitUptoMaxCount() { @@ -45,7 +45,7 @@ public async Task SplitUptoMaxCount() await result.AssertSequenceEqual("the", "quick", "brown fox"); } - [Fact] + [Test] public async Task SplitWithSeparatorSelector() { await using var sequence = TestingSequence.Of(1, 2, null, 3, null, 4, 5, 6); @@ -58,7 +58,7 @@ public async Task SplitWithSeparatorSelector() await reader.ReadEnd(); } - [Fact] + [Test] public async Task SplitWithSeparatorSelectorUptoMaxCount() { await using var sequence = TestingSequence.Of(1, 2, null, 3, null, 4, 5, 6); diff --git a/Tests/SuperLinq.Async.Test/StartsWithTest.cs b/Tests/SuperLinq.Async.Tests/StartsWithTest.cs similarity index 74% rename from Tests/SuperLinq.Async.Test/StartsWithTest.cs rename to Tests/SuperLinq.Async.Tests/StartsWithTest.cs index 41eb9f051..181d5dc1f 100644 --- a/Tests/SuperLinq.Async.Test/StartsWithTest.cs +++ b/Tests/SuperLinq.Async.Tests/StartsWithTest.cs @@ -1,11 +1,11 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class StartsWithTest { - [Theory] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2, 3, 4 }, false)] + [Test] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2, 3, 4 }, false)] public async Task StartsWithWithIntegers(IEnumerable first, IEnumerable second, bool expected) { await using var f = first.AsTestingSequence(); @@ -13,10 +13,10 @@ public async Task StartsWithWithIntegers(IEnumerable first, IEnumerable first, IEnumerable second, bool expected) { await using var f = first.AsTestingSequence(); @@ -25,10 +25,10 @@ public async Task StartsWithWithChars(IEnumerable first, IEnumerable Assert.Equal(expected, await f.StartsWith(s)); } - [Theory] - [InlineData("123", "12", true)] - [InlineData("123", "123", true)] - [InlineData("123", "1234", false)] + [Test] + [Arguments("123", "12", true)] + [Arguments("123", "123", true)] + [Arguments("123", "1234", false)] public async Task StartsWithWithStrings(string first, string second, bool expected) { await using var f = first.AsTestingSequence(); @@ -37,7 +37,7 @@ public async Task StartsWithWithStrings(string first, string second, bool expect Assert.Equal(expected, await f.StartsWith(s)); } - [Fact] + [Test] public async Task StartsWithReturnsTrueIfBothEmpty() { await using var f = Array.Empty().AsTestingSequence(); @@ -46,7 +46,7 @@ public async Task StartsWithReturnsTrueIfBothEmpty() Assert.True(await f.StartsWith(s)); } - [Fact] + [Test] public async Task StartsWithReturnsFalseIfOnlyFirstIsEmpty() { await using var f = Array.Empty().AsTestingSequence(); @@ -55,9 +55,9 @@ public async Task StartsWithReturnsFalseIfOnlyFirstIsEmpty() Assert.False(await f.StartsWith(s)); } - [Theory] - [InlineData("", "", true)] - [InlineData("1", "", true)] + [Test] + [Arguments("", "", true)] + [Arguments("1", "", true)] public async Task StartsWithReturnsTrueIfSecondIsEmpty(string first, string second, bool expected) { await using var f = first.AsTestingSequence(); @@ -66,7 +66,7 @@ public async Task StartsWithReturnsTrueIfSecondIsEmpty(string first, string seco Assert.Equal(expected, await f.StartsWith(s)); } - [Fact] + [Test] public async Task StartsWithUsesSpecifiedEqualityComparerOrDefault() { var first = AsyncSeq(1, 2, 3); diff --git a/Tests/SuperLinq.Async.Tests/SuperLinq.Async.Tests.csproj b/Tests/SuperLinq.Async.Tests/SuperLinq.Async.Tests.csproj new file mode 100644 index 000000000..4c1f0ca19 --- /dev/null +++ b/Tests/SuperLinq.Async.Tests/SuperLinq.Async.Tests.csproj @@ -0,0 +1,46 @@ + + + + net47;net8.0;net9.0 + + false + latest-recommended + + System.Runtime.CompilerServices.ModuleInitializerAttribute + + + + + + + + + + + + + + + + + + + + + + + + + + $(DefineConstants);NO_INDEX + + + + + + + + + + + diff --git a/Tests/SuperLinq.Async.Test/TagFirstLastTest.cs b/Tests/SuperLinq.Async.Tests/TagFirstLastTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/TagFirstLastTest.cs rename to Tests/SuperLinq.Async.Tests/TagFirstLastTest.cs index 28291e698..b6559bd20 100644 --- a/Tests/SuperLinq.Async.Test/TagFirstLastTest.cs +++ b/Tests/SuperLinq.Async.Tests/TagFirstLastTest.cs @@ -1,15 +1,15 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TagFirstLastTest { - [Fact] + [Test] public void TagFirstLastIsLazy() { _ = new AsyncBreakingSequence().TagFirstLast(); _ = new AsyncBreakingSequence().TagFirstLast(BreakingFunc.Of()); } - [Fact] + [Test] public async Task TagFirstLastEmptySequence() { await using var sequence = TestingSequence.Of(); @@ -18,7 +18,7 @@ public async Task TagFirstLastEmptySequence() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task TagFirstLastWithSourceSequenceOfOne() { await using var sequence = TestingSequence.Of(123); @@ -27,7 +27,7 @@ public async Task TagFirstLastWithSourceSequenceOfOne() await result.AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = true }); } - [Fact] + [Test] public async Task TagFirstLastWithSourceSequenceOfTwo() { await using var sequence = TestingSequence.Of(123, 456); @@ -38,7 +38,7 @@ await result.AssertSequenceEqual( new { Item = 456, IsFirst = false, IsLast = true }); } - [Fact] + [Test] public async Task TagFirstLastWithSourceSequenceOfThree() { await using var sequence = TestingSequence.Of(123, 456, 789); diff --git a/Tests/SuperLinq.Async.Test/TakeEveryTest.cs b/Tests/SuperLinq.Async.Tests/TakeEveryTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/TakeEveryTest.cs rename to Tests/SuperLinq.Async.Tests/TakeEveryTest.cs index 88e5bae0b..0bf804468 100644 --- a/Tests/SuperLinq.Async.Test/TakeEveryTest.cs +++ b/Tests/SuperLinq.Async.Tests/TakeEveryTest.cs @@ -1,28 +1,28 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TakeEveryTest { - [Fact] + [Test] public void TakeEveryIsLazy() { _ = new AsyncBreakingSequence().TakeEvery(1); } - [Fact] + [Test] public void TakeEveryNegativeSkip() { _ = Assert.Throws(() => new AsyncBreakingSequence().TakeEvery(-1)); } - [Fact] + [Test] public void TakeEveryOutOfRangeZeroStep() { _ = Assert.Throws(() => new AsyncBreakingSequence().TakeEvery(0)); } - [Fact] + [Test] public async Task TakeEveryEmptySequence() { await using var sequence = TestingSequence.Of(); @@ -31,7 +31,7 @@ public async Task TakeEveryEmptySequence() await result.AssertSequenceEqual(); } - [Fact] + [Test] public async Task TakeEveryNonEmptySequence() { await using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); @@ -40,7 +40,7 @@ public async Task TakeEveryNonEmptySequence() await result.AssertSequenceEqual(1, 2, 3, 4, 5); } - [Fact] + [Test] public async Task TakeEveryOtherOnNonEmptySequence() { await using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); @@ -49,7 +49,7 @@ public async Task TakeEveryOtherOnNonEmptySequence() await result.AssertSequenceEqual(1, 3, 5); } - [Fact] + [Test] public async Task TakeEveryThirdOnNonEmptySequence() { await using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/TakeTest.cs b/Tests/SuperLinq.Async.Tests/TakeTest.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/TakeTest.cs rename to Tests/SuperLinq.Async.Tests/TakeTest.cs index f42e7f5ba..bc923553e 100644 --- a/Tests/SuperLinq.Async.Test/TakeTest.cs +++ b/Tests/SuperLinq.Async.Tests/TakeTest.cs @@ -3,11 +3,11 @@ #if !NO_INDEX -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TakeTest { - [Fact] + [Test] public async Task SameResultsRepeatCallsIntQuery() { var q = (from x in new[] { 9999, 0, 888, -1, 66, -777, 1, 2, -12345 } @@ -22,7 +22,7 @@ where x > int.MinValue Assert.Equal(await q.Take(^9..^0).ToListAsync(), await q.Take(^9..^0).ToListAsync()); } - [Fact] + [Test] public async Task SameResultsRepeatCallsStringQuery() { var q = (from x in new[] { "!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", "" } @@ -37,7 +37,7 @@ public async Task SameResultsRepeatCallsStringQuery() Assert.Equal(await q.Take(^7..^0).ToListAsync(), await q.Take(^7..^0).ToListAsync()); } - [Fact] + [Test] public async Task SourceEmptyCountPositive() { var source = AsyncEnumerable.Empty(); @@ -48,7 +48,7 @@ public async Task SourceEmptyCountPositive() Assert.Empty(await source.Take(^5..^0).ToListAsync()); } - [Fact] + [Test] public async Task SourceNonEmptyCountNegative() { var source = AsyncSeq(2, 5, 9, 1); @@ -56,7 +56,7 @@ public async Task SourceNonEmptyCountNegative() Assert.Empty(await source.Take(^9..0).ToListAsync()); } - [Fact] + [Test] public async Task SourceNonEmptyCountZero() { var source = AsyncSeq(2, 5, 9, 1); @@ -67,7 +67,7 @@ public async Task SourceNonEmptyCountZero() Assert.Empty(await source.Take(^4..^4).ToListAsync()); } - [Fact] + [Test] public async Task SourceNonEmptyCountOne() { var source = AsyncSeq(2, 5, 9, 1); @@ -80,7 +80,7 @@ public async Task SourceNonEmptyCountOne() Assert.Equal(expected, await source.Take(^4..^3).ToListAsync()); } - [Fact] + [Test] public async Task SourceNonEmptyTakeAllExactly() { var source = new[] { 2, 5, 9, 1 }; @@ -92,7 +92,7 @@ public async Task SourceNonEmptyTakeAllExactly() Assert.Equal(source, await source.ToAsyncEnumerable().Take(^source.Length..^0).ToListAsync()); } - [Fact] + [Test] public async Task SourceNonEmptyTakeAllButOne() { var source = AsyncSeq(2, 5, 9, 1); @@ -105,7 +105,7 @@ public async Task SourceNonEmptyTakeAllButOne() Assert.Equal(expected, await source.Take(^4..^1).ToListAsync()); } - [Fact] + [Test] public async Task RunOnce() { var source = AsyncSeq(2, 5, 9, 1); @@ -118,7 +118,7 @@ public async Task RunOnce() Assert.Equal(expected, await source.Take(^4..^1).ToListAsync()); } - [Fact] + [Test] public async Task SourceNonEmptyTakeExcessive() { var source = new int?[] { 2, 5, null, 9, 1 }; @@ -128,7 +128,7 @@ public async Task SourceNonEmptyTakeExcessive() Assert.Equal(source, await source.ToAsyncEnumerable().Take(^(source.Length + 1)..(source.Length + 1)).ToListAsync()); } - [Fact] + [Test] public void ThrowsOnNullSource() { IAsyncEnumerable source = null!; @@ -139,7 +139,7 @@ public void ThrowsOnNullSource() _ = Assert.Throws("source", () => source.Take(^5..^0)); } - [Fact] + [Test] public async Task FollowWithTake() { var source = AsyncSeq(5, 6, 7, 8); @@ -152,7 +152,7 @@ public async Task FollowWithTake() Assert.Equal(expected, await source.Take(^4..^0).Take(^4..^1).Take(^3..^1).Take(^2..^0).ToListAsync()); } - [Fact] + [Test] public async Task FollowWithSkip() { var source = AsyncSeq(1, 2, 3, 4, 5, 6); @@ -165,7 +165,7 @@ public async Task FollowWithSkip() Assert.Equal(expected, await source.Take(^6..^1).Skip(2).Skip(-4).ToListAsync()); } - [Fact] + [Test] public async Task LazyOverflowRegression() { var range = AsyncEnumerable.Range(1, 100); @@ -192,7 +192,7 @@ public async Task LazyOverflowRegression() Assert.Equal(Enumerable.Range(43, 100 - 42), await taken5.ToListAsync()); } - [Fact] + [Test] public async Task OutOfBoundNoException() { static IAsyncEnumerable Source() => AsyncSeq(1, 2, 3, 4, 5); @@ -229,7 +229,7 @@ public async Task OutOfBoundNoException() Assert.Empty(await Source().Take(^int.MaxValue..^int.MaxValue).ToListAsync()); } - [Fact] + [Test] public async Task NonEmptySourceDoNotThrowException() { static IAsyncEnumerable Source() => AsyncSeq(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); @@ -240,7 +240,7 @@ public async Task NonEmptySourceDoNotThrowException() Assert.Empty(await Source().Take(^6..^7).ToListAsync()); } - [Fact] + [Test] public async Task EmptySourceDoNotThrowException() { static IAsyncEnumerable Source() => AsyncSeq(); diff --git a/Tests/SuperLinq.Async.Test/TakeUntilTest.cs b/Tests/SuperLinq.Async.Tests/TakeUntilTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/TakeUntilTest.cs rename to Tests/SuperLinq.Async.Tests/TakeUntilTest.cs index bee6bb3bc..c8ca18f36 100644 --- a/Tests/SuperLinq.Async.Test/TakeUntilTest.cs +++ b/Tests/SuperLinq.Async.Tests/TakeUntilTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TakeUntilTest { - [Fact] + [Test] public void TakeUntilEvaluatesSourceLazily() { _ = new AsyncBreakingSequence().TakeUntil(x => x.Length == 0); } - [Fact] + [Test] public async Task TakeUntilPredicateNeverFalse() { await using var sequence = Enumerable.Range(0, 5).AsTestingSequence(); @@ -17,7 +17,7 @@ await sequence .AssertSequenceEqual(0); } - [Fact] + [Test] public async Task TakeUntilPredicateNeverTrue() { await using var sequence = Enumerable.Range(0, 5).AsTestingSequence(); @@ -26,7 +26,7 @@ await sequence .AssertSequenceEqual(Enumerable.Range(0, 5)); } - [Fact] + [Test] public async Task TakeUntilPredicateBecomesTrueHalfWay() { await using var sequence = Enumerable.Range(0, 5).AsTestingSequence(); @@ -35,7 +35,7 @@ await sequence .AssertSequenceEqual(0, 1, 2); } - [Fact] + [Test] public async Task TakeUntilEvaluatesPredicateLazily() { // Predicate would explode at x == 0, but we never need to evaluate it due to the Take call. diff --git a/Tests/SuperLinq.Async.Test/TestExtensions.cs b/Tests/SuperLinq.Async.Tests/TestExtensions.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/TestExtensions.cs rename to Tests/SuperLinq.Async.Tests/TestExtensions.cs index a21ffb8ec..92c56426e 100644 --- a/Tests/SuperLinq.Async.Test/TestExtensions.cs +++ b/Tests/SuperLinq.Async.Tests/TestExtensions.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; internal static partial class TestExtensions { diff --git a/Tests/SuperLinq.Async.Test/TestingSequence.cs b/Tests/SuperLinq.Async.Tests/TestingSequence.cs similarity index 98% rename from Tests/SuperLinq.Async.Test/TestingSequence.cs rename to Tests/SuperLinq.Async.Tests/TestingSequence.cs index 431c5f5bf..8a48bc6b2 100644 --- a/Tests/SuperLinq.Async.Test/TestingSequence.cs +++ b/Tests/SuperLinq.Async.Tests/TestingSequence.cs @@ -1,8 +1,8 @@ using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; -using static Test.Async.TestingSequence; +using static SuperLinq.Async.Tests.TestingSequence; -namespace Test.Async; +namespace SuperLinq.Async.Tests; internal static class TestingSequence { @@ -143,7 +143,7 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToke public sealed class TestingSequenceTest { - [Fact] + [Test] public async Task TestingSequencePublicPropertiesTest() { await using var sequence = Of(1, 2, 3, 4); @@ -165,7 +165,7 @@ public async Task TestingSequencePublicPropertiesTest() Assert.True(sequence.IsDisposed); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateDisposal() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -185,7 +185,7 @@ static async Task Act() await AssertSequenceBehavior(Act, ExpectedDisposal); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateNumberOfUsages() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -212,7 +212,7 @@ static async Task Act() await AssertSequenceBehavior(Act, TooManyEnumerations); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateDisposeOnDisposedSequence() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -234,7 +234,7 @@ static async Task Act() await AssertSequenceBehavior(Act, TooManyDisposals); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateMoveNextOnDisposedSequence() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -256,7 +256,7 @@ static async Task Act() await AssertSequenceBehavior(Act, MoveNextPostDisposal); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateMoveNextOnCompletedSequence() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -280,7 +280,7 @@ static async Task Act() await AssertSequenceBehavior(Act, MoveNextPostEnumeration); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateCurrentOnDisposedSequence() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -302,7 +302,7 @@ static async Task Act() await AssertSequenceBehavior(Act, CurrentPostDisposal); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateCurrentOnEndedSequence() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) @@ -326,7 +326,7 @@ static async Task Act() await AssertSequenceBehavior(Act, CurrentPostEnumeration); } - [Fact] + [Test] public async Task TestingSequenceShouldValidateSimultaneousEnumeration() { static async IAsyncEnumerable InvalidUsage(IAsyncEnumerable enumerable) diff --git a/Tests/SuperLinq.Async.Test/ThrowTest.cs b/Tests/SuperLinq.Async.Tests/ThrowTest.cs similarity index 87% rename from Tests/SuperLinq.Async.Test/ThrowTest.cs rename to Tests/SuperLinq.Async.Tests/ThrowTest.cs index c6fa8a255..50b4ff095 100644 --- a/Tests/SuperLinq.Async.Test/ThrowTest.cs +++ b/Tests/SuperLinq.Async.Tests/ThrowTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ThrowTest { - [Fact] + [Test] public void ThrowIsLazy() { _ = AsyncSuperEnumerable.Throw(new TestException()); } - [Fact] + [Test] public async Task ThrowBehavior() { var src = new TestException(); diff --git a/Tests/SuperLinq.Async.Test/TimeoutTest.cs b/Tests/SuperLinq.Async.Tests/TimeoutTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/TimeoutTest.cs rename to Tests/SuperLinq.Async.Tests/TimeoutTest.cs index 24a48864c..087ceead9 100644 --- a/Tests/SuperLinq.Async.Test/TimeoutTest.cs +++ b/Tests/SuperLinq.Async.Tests/TimeoutTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TimeoutTest { - [Fact] + [Test] public void TimeoutIsLazy() { _ = new AsyncBreakingSequence().Timeout(TimeSpan.FromSeconds(1)); } - [Fact] + [Test] public async Task TimeoutNoException() { await using var ts = AsyncEnumerable.Range(1, 5) @@ -24,7 +24,7 @@ public async Task TimeoutNoException() await result.AssertSequenceEqual(1, 2, 3, 4, 5); } - [Fact] + [Test] public async Task TimeoutException() { await using var ts = AsyncEnumerable.Range(1, 5) @@ -41,7 +41,7 @@ public async Task TimeoutException() async () => await result.Consume()); } - [Fact] + [Test] public async Task TimeoutExceptionWithoutCancellation() { await using var ts = AsyncEnumerable.Range(1, 5) @@ -58,7 +58,7 @@ public async Task TimeoutExceptionWithoutCancellation() async () => await result.Consume()); } - [Fact] + [Test] public async Task TimeoutExceptionWithoutOperationCanceledExceptionInnerException() { await using var ts = new SequenceWithoutThrowIfCancellationRequested() @@ -72,7 +72,7 @@ public async Task TimeoutExceptionWithoutOperationCanceledExceptionInnerExceptio Assert.Null(timeoutException.InnerException); } - [Fact] + [Test] public async Task TimeoutExceptionWithOperationCanceledExceptionInnerException() { await using var ts = new SequenceWithThrowIfCancellationRequested() diff --git a/Tests/SuperLinq.Async.Test/TraverseTest.cs b/Tests/SuperLinq.Async.Tests/TraverseTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/TraverseTest.cs rename to Tests/SuperLinq.Async.Tests/TraverseTest.cs index 3480e4a08..37d1a9312 100644 --- a/Tests/SuperLinq.Async.Test/TraverseTest.cs +++ b/Tests/SuperLinq.Async.Tests/TraverseTest.cs @@ -1,20 +1,20 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TraverseTest { - [Fact] + [Test] public void TraverseDepthFirstIsStreaming() { _ = AsyncSuperEnumerable.TraverseDepthFirst(new object(), o => new AsyncBreakingSequence()); } - [Fact] + [Test] public void TraverseBreadthFirstIsStreaming() { _ = AsyncSuperEnumerable.TraverseBreadthFirst(new object(), o => new AsyncBreakingSequence()); } - [Fact] + [Test] public async Task TraverseDepthFirstPreservesChildrenOrder() { await using var root = Enumerable.Range(1, 10).AsTestingSequence(); @@ -23,7 +23,7 @@ public async Task TraverseDepthFirstPreservesChildrenOrder() await res.AssertSequenceEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } - [Fact] + [Test] public async Task TraverseBreadthFirstPreservesChildrenOrder() { await using var root = Enumerable.Range(1, 10).AsTestingSequence(); @@ -46,7 +46,7 @@ private static class Tree public static Tree New(T value, params Tree[] children) => new(value, children); } - [Fact] + [Test] public Task TraverseBreadthFirstTraversesBreadthFirst() { var tree = Tree.New(1, @@ -60,7 +60,7 @@ public Task TraverseBreadthFirstTraversesBreadthFirst() return res.AssertSequenceEqual(1, 2, 5, 3, 6); } - [Fact] + [Test] public Task TraverseDepthFirstTraversesDepthFirst() { var tree = Tree.New(1, diff --git a/Tests/SuperLinq.Async.Test/TrySingleTest.cs b/Tests/SuperLinq.Async.Tests/TrySingleTest.cs similarity index 89% rename from Tests/SuperLinq.Async.Test/TrySingleTest.cs rename to Tests/SuperLinq.Async.Tests/TrySingleTest.cs index 7c2bb71b6..0ee361bdf 100644 --- a/Tests/SuperLinq.Async.Test/TrySingleTest.cs +++ b/Tests/SuperLinq.Async.Tests/TrySingleTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class TrySingleTest { - [Fact] + [Test] public async Task TrySingleWithEmptySource() { await using var source = AsyncEnumerable.Empty().AsTestingSequence(); @@ -13,7 +13,7 @@ public async Task TrySingleWithEmptySource() Assert.Null(value); } - [Fact] + [Test] public async Task TrySingleWithSingleton() { await using var source = AsyncSeq(10).AsTestingSequence(); @@ -24,7 +24,7 @@ public async Task TrySingleWithSingleton() Assert.Equal(10, value); } - [Fact] + [Test] public async Task TrySingleWithMoreThanOne() { await using var source = AsyncSeq(10, 20).AsTestingSequence(); @@ -35,7 +35,7 @@ public async Task TrySingleWithMoreThanOne() Assert.Null(value); } - [Fact] + [Test] public async Task TrySingleDoesNotConsumeMoreThanTwoElementsFromTheSequence() { await using var seq = AsyncSuperEnumerable @@ -51,10 +51,10 @@ public async Task TrySingleDoesNotConsumeMoreThanTwoElementsFromTheSequence() Assert.Equal(0, value); } - [Theory] - [InlineData(0, "zero")] - [InlineData(1, "one")] - [InlineData(2, "many")] + [Test] + [Arguments(0, "zero")] + [Arguments(1, "one")] + [Arguments(2, "many")] public async Task TrySingleEnumeratesOnceOnlyAndDisposes(int numberOfElements, string expectedCardinality) { await using var seq = AsyncEnumerable.Range(1, numberOfElements).AsTestingSequence(); @@ -62,10 +62,10 @@ public async Task TrySingleEnumeratesOnceOnlyAndDisposes(int numberOfElements, s Assert.Equal(expectedCardinality, cardinality); } - [Theory] - [InlineData(0, 0)] - [InlineData(1, 1)] - [InlineData(2, 0)] + [Test] + [Arguments(0, 0)] + [Arguments(1, 1)] + [Arguments(2, 0)] public async Task TrySingleShouldReturnDefaultOrSingleValue(int numberOfElements, int expectedResult) { await using var seq = AsyncEnumerable.Range(1, numberOfElements).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/UsingTest.cs b/Tests/SuperLinq.Async.Tests/UsingTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/UsingTest.cs rename to Tests/SuperLinq.Async.Tests/UsingTest.cs index 09dc6af18..60fb274a3 100644 --- a/Tests/SuperLinq.Async.Test/UsingTest.cs +++ b/Tests/SuperLinq.Async.Tests/UsingTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class UsingTest { - [Fact] + [Test] public void UsingIsLazy() { _ = AsyncSuperEnumerable.Using( @@ -10,7 +10,7 @@ public void UsingIsLazy() BreakingFunc.Of>()); } - [Fact] + [Test] public async Task UsingDisposesCorrectly() { var starts = 0; @@ -36,7 +36,7 @@ IEnumerable Test(TestDisposable disposable) Assert.Equal(1, starts); } - [Fact] + [Test] public async Task UsingDisposesOnIterationError() { var starts = 0; @@ -63,7 +63,7 @@ IEnumerable Test(TestDisposable disposable) Assert.Equal(1, starts); } - [Fact] + [Test] public async Task UsingDisposesOnFunctionError() { TestDisposable? dis = null; diff --git a/Tests/SuperLinq.Async.Test/WatchableEnumerator.cs b/Tests/SuperLinq.Async.Tests/WatchableEnumerator.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/WatchableEnumerator.cs rename to Tests/SuperLinq.Async.Tests/WatchableEnumerator.cs index 2b4cfdd0a..58aae6b5a 100644 --- a/Tests/SuperLinq.Async.Test/WatchableEnumerator.cs +++ b/Tests/SuperLinq.Async.Tests/WatchableEnumerator.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; internal sealed class WatchableEnumerator : IAsyncEnumerator { diff --git a/Tests/SuperLinq.Async.Test/WhereLagTest.cs b/Tests/SuperLinq.Async.Tests/WhereLagTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/WhereLagTest.cs rename to Tests/SuperLinq.Async.Tests/WhereLagTest.cs index 3978bf03b..d4e8bd812 100644 --- a/Tests/SuperLinq.Async.Test/WhereLagTest.cs +++ b/Tests/SuperLinq.Async.Tests/WhereLagTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class WhereLagTest { - [Fact] + [Test] public void WhereLagIsLazy() { _ = new AsyncBreakingSequence().WhereLag(5, BreakingFunc.Of()); @@ -11,14 +11,14 @@ public void WhereLagIsLazy() _ = new AsyncBreakingSequence().WhereLag(5, -1, BreakingFunc.Of>()); } - [Fact] + [Test] public void WhereLagZeroOffset() { _ = Assert.Throws(() => new AsyncBreakingSequence().WhereLag(0, BreakingFunc.Of())); } - [Fact] + [Test] public async Task WhereLagExplicitDefaultValue() { await using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -27,7 +27,7 @@ await result.AssertSequenceEqual( 2, 7, 17, 27, 37, 47, 57, 67, 77, 87, 97); } - [Fact] + [Test] public async Task WhereLagImplicitDefaultValue() { await using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -36,7 +36,7 @@ await result.AssertSequenceEqual( 1, 7, 17, 27, 37, 47, 57, 67, 77, 87, 97); } - [Fact] + [Test] public async Task WhereLagOffsetGreaterThanSequenceLength() { await using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -44,7 +44,7 @@ public async Task WhereLagOffsetGreaterThanSequenceLength() await result.AssertSequenceEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public async Task WhereLagWithNullableReferences() { await using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); @@ -52,7 +52,7 @@ public async Task WhereLagWithNullableReferences() await result.AssertSequenceEqual("foo", "baz"); } - [Fact] + [Test] public async Task WhereLagWithNonNullableReferences() { await using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/WhereLeadTest.cs b/Tests/SuperLinq.Async.Tests/WhereLeadTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/WhereLeadTest.cs rename to Tests/SuperLinq.Async.Tests/WhereLeadTest.cs index 470708156..569608837 100644 --- a/Tests/SuperLinq.Async.Test/WhereLeadTest.cs +++ b/Tests/SuperLinq.Async.Tests/WhereLeadTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class WhereLeadTest { - [Fact] + [Test] public void WhereLeadIsLazy() { _ = new AsyncBreakingSequence().WhereLead(5, BreakingFunc.Of()); @@ -11,14 +11,14 @@ public void WhereLeadIsLazy() _ = new AsyncBreakingSequence().WhereLead(5, -1, BreakingFunc.Of>()); } - [Fact] + [Test] public void WhereLeadZeroOffset() { _ = Assert.Throws(() => new AsyncBreakingSequence().WhereLead(0, BreakingFunc.Of())); } - [Fact] + [Test] public async Task WhereLeadExplicitDefaultValue() { await using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -27,7 +27,7 @@ await result.AssertSequenceEqual( 7, 17, 27, 37, 47, 48, 57, 67, 77, 87, 97, 100); } - [Fact] + [Test] public async Task WhereLeadImplicitDefaultValue() { await using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -36,7 +36,7 @@ await result.AssertSequenceEqual( 9, 19, 29, 39, 48, 49, 59, 69, 79, 89, 99); } - [Fact] + [Test] public async Task WhereLeadOffsetGreaterThanSequenceLength() { await using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -44,7 +44,7 @@ public async Task WhereLeadOffsetGreaterThanSequenceLength() await result.AssertSequenceEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public async Task WhereLeadWithNullableReferences() { await using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); @@ -52,7 +52,7 @@ public async Task WhereLeadWithNullableReferences() await result.AssertSequenceEqual("foo", "baz"); } - [Fact] + [Test] public async Task WhereLeadWithNonNullableReferences() { await using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/WhereTest.cs b/Tests/SuperLinq.Async.Tests/WhereTest.cs similarity index 90% rename from Tests/SuperLinq.Async.Test/WhereTest.cs rename to Tests/SuperLinq.Async.Tests/WhereTest.cs index 5bfa519a8..117ef5351 100644 --- a/Tests/SuperLinq.Async.Test/WhereTest.cs +++ b/Tests/SuperLinq.Async.Tests/WhereTest.cs @@ -1,23 +1,23 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class WhereTest { - [Fact] + [Test] public void WhereIsLazy() { _ = new AsyncBreakingSequence().Where(new AsyncBreakingSequence()); } - [Theory] - [InlineData(2, 3)] - [InlineData(3, 2)] + [Test] + [Arguments(2, 3)] + [Arguments(3, 2)] public async Task WhereRequiresEqualLengths(int sLength, int fLength) { _ = await Assert.ThrowsAsync(async () => await AsyncEnumerable.Repeat(1, sLength).Where(AsyncEnumerable.Repeat(false, fLength)).Consume()); } - [Fact] + [Test] public async Task WhereFiltersIntSequence() { var seq = AsyncEnumerable.Range(1, 10); @@ -29,7 +29,7 @@ await result.AssertSequenceEqual( seq.Where(x => x % 2 == 0)); } - [Fact] + [Test] public async Task WhereFiltersStringSequence() { var words = Seq("foo", "hello", "world", "Bar", "QuX", "ay", "az"); diff --git a/Tests/SuperLinq.Async.Test/WhileTest.cs b/Tests/SuperLinq.Async.Tests/WhileTest.cs similarity index 93% rename from Tests/SuperLinq.Async.Test/WhileTest.cs rename to Tests/SuperLinq.Async.Tests/WhileTest.cs index f863ac61b..58a8cbd90 100644 --- a/Tests/SuperLinq.Async.Test/WhileTest.cs +++ b/Tests/SuperLinq.Async.Tests/WhileTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class WhileTest { - [Fact] + [Test] public void WhileIsLazy() { _ = AsyncSuperEnumerable.While( @@ -13,7 +13,7 @@ public void WhileIsLazy() new AsyncBreakingSequence()); } - [Fact] + [Test] public async Task WhileBehavior() { await using var ts = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/WindowLeftTest.cs b/Tests/SuperLinq.Async.Tests/WindowLeftTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/WindowLeftTest.cs rename to Tests/SuperLinq.Async.Tests/WindowLeftTest.cs index 0d4e7eb37..e916e5acc 100644 --- a/Tests/SuperLinq.Async.Test/WindowLeftTest.cs +++ b/Tests/SuperLinq.Async.Tests/WindowLeftTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class WindowLeftTest { - [Fact] + [Test] public void WindowLeftIsLazy() { _ = new AsyncBreakingSequence().WindowLeft(1); } - [Fact] + [Test] public async Task WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() { var sequence = AsyncEnumerable.Range(0, 3); @@ -23,7 +23,7 @@ public async Task WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() Assert.Equal(1, window2[0]); } - [Fact] + [Test] public async Task WindowModifiedAfterMoveNextDoesNotAffectNextWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -38,7 +38,7 @@ public async Task WindowModifiedAfterMoveNextDoesNotAffectNextWindow() Assert.Equal(1, window2[0]); } - [Fact] + [Test] public async Task WindowModifiedDoesNotAffectPreviousWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -53,14 +53,14 @@ public async Task WindowModifiedDoesNotAffectPreviousWindow() Assert.Equal(1, window1[1]); } - [Fact] + [Test] public void WindowLeftWithNegativeWindowSize() { _ = Assert.Throws(() => AsyncEnumerable.Repeat(1, 10).WindowLeft(-5)); } - [Fact] + [Test] public async Task WindowLeftWithEmptySequence() { await using var xs = AsyncEnumerable.Empty().AsTestingSequence(); @@ -70,7 +70,7 @@ public async Task WindowLeftWithEmptySequence() await result.AssertEmpty(); } - [Fact] + [Test] public async Task WindowLeftWithSingleElement() { var sequence = Enumerable.Range(1, 100).ToArray(); @@ -87,7 +87,7 @@ public async Task WindowLeftWithSingleElement() Assert.Equal(item.Single(), sequence[index]); } - [Fact] + [Test] public async Task WindowLeftWithWindowSizeLargerThanSequence() { await using var sequence = AsyncEnumerable.Range(1, 5).AsTestingSequence(); @@ -102,7 +102,7 @@ public async Task WindowLeftWithWindowSizeLargerThanSequence() await reader.ReadEnd(); } - [Fact] + [Test] public async Task WindowLeftWithWindowSizeSmallerThanSequence() { await using var sequence = AsyncEnumerable.Range(1, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/WindowRightTest.cs b/Tests/SuperLinq.Async.Tests/WindowRightTest.cs similarity index 96% rename from Tests/SuperLinq.Async.Test/WindowRightTest.cs rename to Tests/SuperLinq.Async.Tests/WindowRightTest.cs index 5cfd87b37..f740bbd40 100644 --- a/Tests/SuperLinq.Async.Test/WindowRightTest.cs +++ b/Tests/SuperLinq.Async.Tests/WindowRightTest.cs @@ -1,14 +1,14 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class WindowRightTest { - [Fact] + [Test] public void WindowRightIsLazy() { _ = new AsyncBreakingSequence().WindowRight(1); } - [Fact] + [Test] public async Task WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() { var sequence = AsyncEnumerable.Range(0, 3); @@ -23,7 +23,7 @@ public async Task WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() Assert.Equal(0, window2[0]); } - [Fact] + [Test] public async Task WindowModifiedAfterMoveNextDoesNotAffectNextWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -38,7 +38,7 @@ public async Task WindowModifiedAfterMoveNextDoesNotAffectNextWindow() Assert.Equal(0, window2[0]); } - [Fact] + [Test] public async Task WindowModifiedDoesNotAffectPreviousWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -53,14 +53,14 @@ public async Task WindowModifiedDoesNotAffectPreviousWindow() Assert.Equal(0, window1[0]); } - [Fact] + [Test] public void WindowRightWithNegativeWindowSize() { _ = Assert.Throws(() => AsyncEnumerable.Repeat(1, 10).WindowRight(-5)); } - [Fact] + [Test] public async Task WindowRightWithEmptySequence() { await using var xs = Enumerable.Empty().AsTestingSequence(); @@ -70,7 +70,7 @@ public async Task WindowRightWithEmptySequence() await result.AssertEmpty(); } - [Fact] + [Test] public async Task WindowRightWithSingleElement() { IList[] result; @@ -85,7 +85,7 @@ public async Task WindowRightWithSingleElement() Assert.Equal(item.Single(), index + 1); } - [Fact] + [Test] public async Task WindowRightWithWindowSizeLargerThanSequence() { await using var sequence = AsyncEnumerable.Range(1, 5).AsTestingSequence(); @@ -99,7 +99,7 @@ public async Task WindowRightWithWindowSizeLargerThanSequence() await reader.ReadEnd(); } - [Fact] + [Test] public async Task WindowRightWithWindowSizeSmallerThanSequence() { await using var sequence = AsyncEnumerable.Range(1, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/WindowTest.cs b/Tests/SuperLinq.Async.Tests/WindowTest.cs similarity index 97% rename from Tests/SuperLinq.Async.Test/WindowTest.cs rename to Tests/SuperLinq.Async.Tests/WindowTest.cs index 9d7b146df..20243e4f1 100644 --- a/Tests/SuperLinq.Async.Test/WindowTest.cs +++ b/Tests/SuperLinq.Async.Tests/WindowTest.cs @@ -1,4 +1,4 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; /// /// Verify the behavior of the Window operator @@ -8,13 +8,13 @@ public sealed class WindowTests /// /// Verify that Window behaves in a lazy manner /// - [Fact] + [Test] public void TestWindowIsLazy() { _ = new AsyncBreakingSequence().Window(1); } - [Fact] + [Test] public async Task WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -29,7 +29,7 @@ public async Task WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() Assert.Equal(1, window2[0]); } - [Fact] + [Test] public async Task WindowModifiedAfterMoveNextDoesNotAffectNextWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -44,7 +44,7 @@ public async Task WindowModifiedAfterMoveNextDoesNotAffectNextWindow() Assert.Equal(1, window2[0]); } - [Fact] + [Test] public async Task WindowModifiedDoesNotAffectPreviousWindow() { await using var sequence = AsyncEnumerable.Range(0, 3).AsTestingSequence(); @@ -62,7 +62,7 @@ public async Task WindowModifiedDoesNotAffectPreviousWindow() /// /// Verify that a negative window size results in an exception /// - [Fact] + [Test] public void TestWindowNegativeWindowSizeException() { _ = Assert.Throws(() => @@ -73,7 +73,7 @@ public void TestWindowNegativeWindowSizeException() /// Verify that a sliding window of an any size over an empty sequence /// is an empty sequence /// - [Fact] + [Test] public async Task TestWindowEmptySequence() { await using var sequence = TestingSequence.Of(); @@ -86,7 +86,7 @@ public async Task TestWindowEmptySequence() /// Verify that decomposing a sequence into windows of a single item /// degenerates to the original sequence. /// - [Fact] + [Test] public async Task TestWindowOfSingleElement() { await using var sequence = Enumerable.Range(0, 100).AsTestingSequence(); @@ -105,7 +105,7 @@ public async Task TestWindowOfSingleElement() /// Verify that asking for a window large than the source sequence results /// in a empty sequence. /// - [Fact] + [Test] public async Task TestWindowLargerThanSequence() { await using var sequence = Enumerable.Range(0, 100).AsTestingSequence(); @@ -121,7 +121,7 @@ public async Task TestWindowLargerThanSequence() /// Verify that asking for a window smaller than the source sequence results /// in N sequences, where N = (source.Count() - windowSize) + 1. /// - [Fact] + [Test] public async Task TestWindowSmallerThanSequence() { await using var sequence = Enumerable.Range(0, 100).AsTestingSequence(); @@ -140,7 +140,7 @@ public async Task TestWindowSmallerThanSequence() /// Verify that later windows do not modify any of the previous ones. /// - [Fact] + [Test] public async Task TestWindowWindowsImmutability() { await using var windows = AsyncEnumerable.Range(1, 5).Window(2).AsTestingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ZipLongestTest.cs b/Tests/SuperLinq.Async.Tests/ZipLongestTest.cs similarity index 92% rename from Tests/SuperLinq.Async.Test/ZipLongestTest.cs rename to Tests/SuperLinq.Async.Tests/ZipLongestTest.cs index 530737fc3..458c99d47 100644 --- a/Tests/SuperLinq.Async.Test/ZipLongestTest.cs +++ b/Tests/SuperLinq.Async.Tests/ZipLongestTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ZipLongestTest { - [Fact] + [Test] public void ZipLongestIsLazy() { var bs = new AsyncBreakingSequence(); @@ -11,7 +11,7 @@ public void ZipLongestIsLazy() _ = bs.ZipLongest(bs, bs, bs, BreakingFunc.Of()); } - [Fact] + [Test] public async Task TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -20,8 +20,8 @@ public async Task TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() await s1.ZipLongest(new AsyncBreakingSequence()).Consume()); } - [Theory] - [InlineData(1), InlineData(2)] + [Test] + [Arguments(1), Arguments(2)] public async Task TwoParamsWorksProperly(int offset) { var o1 = ((offset + 0) % 2) + 2; @@ -37,7 +37,7 @@ await ts1.ZipLongest(ts2).AssertSequenceEqual( x > o2 ? 0 : x))); } - [Fact] + [Test] public async Task ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -47,8 +47,8 @@ public async Task ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() await s1.ZipLongest(s2, new AsyncBreakingSequence()).Consume()); } - [Theory] - [InlineData(1), InlineData(2), InlineData(3)] + [Test] + [Arguments(1), Arguments(2), Arguments(3)] public async Task ThreeParamsWorksProperly(int offset) { var o1 = ((offset + 0) % 3) + 2; @@ -67,7 +67,7 @@ await ts1.ZipLongest(ts2, ts3).AssertSequenceEqual( x > o3 ? 0 : x))); } - [Fact] + [Test] public async Task FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -78,8 +78,8 @@ public async Task FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() await s1.ZipLongest(s2, s3, new AsyncBreakingSequence()).Consume()); } - [Theory] - [InlineData(1), InlineData(2), InlineData(3), InlineData(4)] + [Test] + [Arguments(1), Arguments(2), Arguments(3), Arguments(4)] public async Task FourParamsWorksProperly(int offset) { var o1 = ((offset + 0) % 4) + 2; diff --git a/Tests/SuperLinq.Async.Test/ZipMapTest.cs b/Tests/SuperLinq.Async.Tests/ZipMapTest.cs similarity index 94% rename from Tests/SuperLinq.Async.Test/ZipMapTest.cs rename to Tests/SuperLinq.Async.Tests/ZipMapTest.cs index 3e8e271a4..04d75d0b5 100644 --- a/Tests/SuperLinq.Async.Test/ZipMapTest.cs +++ b/Tests/SuperLinq.Async.Tests/ZipMapTest.cs @@ -1,11 +1,11 @@ using System.Globalization; using System.Text.RegularExpressions; -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ZipMapTest { - [Fact] + [Test] public async Task ZipMapIntTransformation() { var range = Enumerable.Range(1, 10); @@ -14,7 +14,7 @@ await ts1.ZipMap(i => i.ToString(CultureInfo.InvariantCulture)).AssertSequenceEq range.Select(i => (i, i.ToString(CultureInfo.InvariantCulture)))); } - [Fact] + [Test] public async Task ZipMapStringTransformation() { var words = Seq("foo", "bar", "FOO", "Bar", "baz", "QUx", "bAz", "QuX"); @@ -24,7 +24,7 @@ await ts1.ZipMap(s => s.Length).AssertSequenceEqual( words.Select(s => (s, s.Length))); } - [Fact] + [Test] public async Task ZipMapRegexChoose() { var words = Seq("foo", "hello", "world", "Bar", "QuX", "ay", "az"); @@ -35,7 +35,7 @@ await ts1.ZipMap(s => Regex.IsMatch(s, @"^\w{3}$")) .AssertSequenceEqual("foo", "Bar", "QuX"); } - [Fact] + [Test] public void ZipMapIsLazy() { var bs = new AsyncBreakingSequence(); diff --git a/Tests/SuperLinq.Async.Test/ZipShortestTest.cs b/Tests/SuperLinq.Async.Tests/ZipShortestTest.cs similarity index 95% rename from Tests/SuperLinq.Async.Test/ZipShortestTest.cs rename to Tests/SuperLinq.Async.Tests/ZipShortestTest.cs index d00f6b6d6..d7f589a72 100644 --- a/Tests/SuperLinq.Async.Test/ZipShortestTest.cs +++ b/Tests/SuperLinq.Async.Tests/ZipShortestTest.cs @@ -1,8 +1,8 @@ -namespace Test.Async; +namespace SuperLinq.Async.Tests; public sealed class ZipShortestTest { - [Fact] + [Test] public void ZipShortestIsLazy() { var bs = new AsyncBreakingSequence(); @@ -11,7 +11,7 @@ public void ZipShortestIsLazy() _ = bs.ZipShortest(bs, bs, bs, BreakingFunc.Of()); } - [Fact] + [Test] public async Task TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { await using var s1 = TestingSequence.Of(1, 2); @@ -20,8 +20,8 @@ public async Task TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() await s1.ZipShortest(new AsyncBreakingSequence()).Consume()); } - [Theory] - [InlineData(1), InlineData(2)] + [Test] + [Arguments(1), Arguments(2)] public async Task TwoParamsWorksProperly(int offset) { var o1 = ((offset + 0) % 2) + 2; @@ -35,7 +35,7 @@ await ts1.ZipShortest(ts2).AssertSequenceEqual( .Select(x => (x, x))); } - [Fact] + [Test] public async Task ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { await using var s1 = TestingSequence.Of(1, 2); @@ -45,8 +45,8 @@ public async Task ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() await s1.ZipShortest(s2, new AsyncBreakingSequence()).Consume()); } - [Theory] - [InlineData(1), InlineData(2), InlineData(3)] + [Test] + [Arguments(1), Arguments(2), Arguments(3)] public async Task ThreeParamsWorksProperly(int offset) { var o1 = ((offset + 0) % 3) + 2; @@ -62,7 +62,7 @@ await ts1.ZipShortest(ts2, ts3).AssertSequenceEqual( .Select(x => (x, x, x))); } - [Fact] + [Test] public async Task FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { await using var s1 = TestingSequence.Of(1, 2); @@ -73,8 +73,8 @@ public async Task FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() await s1.ZipShortest(s2, s3, new AsyncBreakingSequence()).Consume()); } - [Theory] - [InlineData(1), InlineData(2), InlineData(3), InlineData(4)] + [Test] + [Arguments(1), Arguments(2), Arguments(3), Arguments(4)] public async Task FourParamsWorksProperly(int offset) { var o1 = ((offset + 0) % 4) + 2; @@ -92,7 +92,7 @@ await ts1.ZipShortest(ts2, ts3, ts4).AssertSequenceEqual( .Select(x => (x, x, x, x))); } - [Fact] + [Test] public async Task ZipShortestNotIterateUnnecessaryElements() { using (var s1 = TestingSequence.Of(1, 2)) diff --git a/Tests/SuperLinq.Test/DuplicatesTest.cs b/Tests/SuperLinq.Test/DuplicatesTest.cs deleted file mode 100644 index 7433ce07f..000000000 --- a/Tests/SuperLinq.Test/DuplicatesTest.cs +++ /dev/null @@ -1,60 +0,0 @@ -namespace Test; - -public sealed class DuplicatesTest -{ - [Fact] - public void DuplicatesIsLazy() - { - _ = new BreakingSequence().Duplicates(); - } - - [Theory] - [InlineData(new int[] { 1, 2, 3 }, new int[] { })] - [InlineData(new int[] { 1, 2, 1, 3, 1, 2, 1 }, new int[] { 1, 2 })] - [InlineData(new int[] { 3, 3, 2, 2, 1, 1 }, new int[] { 3, 2, 1 })] - public void DuplicatesBehavior(IEnumerable source, IEnumerable expected) - { - using var ts = source.AsTestingSequence(); - - var result = ts.Duplicates(); - result.AssertSequenceEqual(expected); - } - - public static IEnumerable GetStringParameters() - { - yield return new object[] - { - new string[] { "foo", "bar", "qux" }, - StringComparer.Ordinal, - Array.Empty(), - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.Ordinal, - Array.Empty(), - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - new string[] { "FOO" }, - }; - yield return new object[] - { - new string[] { "Bar", "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - new string[] { "FOO", "bar" }, - }; - } - - [Theory] - [MemberData(nameof(GetStringParameters))] - public void DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, IEnumerable expected) - { - using var ts = source.AsTestingSequence(); - - var result = ts.Duplicates(comparer); - result.AssertSequenceEqual(expected); - } -} diff --git a/Tests/SuperLinq.Test/HasDuplicatesTest.cs b/Tests/SuperLinq.Test/HasDuplicatesTest.cs deleted file mode 100644 index 35447f4af..000000000 --- a/Tests/SuperLinq.Test/HasDuplicatesTest.cs +++ /dev/null @@ -1,63 +0,0 @@ -namespace Test; - -public sealed class HasDuplicatesTest -{ - [Fact] - public void DuplicatesDoesNotEnumerateUnnecessarily() - { - using var ts = Seq(1, 2, 3).Concat(SeqExceptionAt(2)).AsTestingSequence(); - - var result = ts.HasDuplicates(); - Assert.True(result); - } - - [Theory] - [InlineData(new int[] { 1, 2, 3 }, false)] - [InlineData(new int[] { 1, 2, 1, 3, 1, 2, 1 }, true)] - [InlineData(new int[] { 3, 3, 2, 2, 1, 1 }, true)] - public void DuplicatesBehavior(IEnumerable source, bool expected) - { - using var ts = source.AsTestingSequence(); - - var result = ts.HasDuplicates(); - Assert.Equal(expected, result); - } - - public static IEnumerable GetStringParameters() - { - yield return new object[] - { - new string[] { "foo", "bar", "qux" }, - StringComparer.Ordinal, - false, - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.Ordinal, - false, - }; - yield return new object[] - { - new string[] { "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - true, - }; - yield return new object[] - { - new string[] { "Bar", "foo", "FOO", "bar", "qux" }, - StringComparer.OrdinalIgnoreCase, - true, - }; - } - - [Theory] - [MemberData(nameof(GetStringParameters))] - public void DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, bool expected) - { - using var ts = source.AsTestingSequence(); - - var result = ts.HasDuplicates(comparer); - Assert.Equal(expected, result); - } -} diff --git a/Tests/SuperLinq.Test/SuperLinq.Test.csproj b/Tests/SuperLinq.Test/SuperLinq.Test.csproj deleted file mode 100644 index 177e37c29..000000000 --- a/Tests/SuperLinq.Test/SuperLinq.Test.csproj +++ /dev/null @@ -1,40 +0,0 @@ - - - - - - SuperLinq.Test - SuperLinq.Test - Test - net47;$(TargetFrameworks) - - false - latest-recommended - - - - - - - - - - - - - - - - $(DefineConstants);NO_INDEX - - - - - - - - - - - - diff --git a/Tests/SuperLinq.Test/TrySingleTest.cs b/Tests/SuperLinq.Test/TrySingleTest.cs deleted file mode 100644 index a25f0a155..000000000 --- a/Tests/SuperLinq.Test/TrySingleTest.cs +++ /dev/null @@ -1,162 +0,0 @@ -using System.Collections; - -namespace Test; - -public sealed class TrySingleTest -{ - public static IEnumerable GetSequences(IEnumerable seq) => - seq.Select(x => (int?)x) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] - public void TrySingleWithEmptySource(IDisposableEnumerable seq) - { - using (seq) - { - var (cardinality, value) = seq.TrySingle("zero", "one", "many"); - - Assert.Equal("zero", cardinality); - Assert.Null(value); - } - } - - public static IEnumerable GetSingletonSequences(IEnumerable seq) => - seq.Select(x => (int?)x) - .GetCollectionSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetSingletonSequences), new int[] { 10 })] - public void TrySingleWithSingleton(IDisposableEnumerable seq) - { - using (seq) - { - var (cardinality, value) = seq.TrySingle("zero", "one", "many"); - - Assert.Equal("one", cardinality); - Assert.Equal(10, value); - } - } - - [Fact] - public void TrySingleWithSingletonCollection() - { - var source = new BreakingSingleElementCollection(10); - var (cardinality, value) = source.TrySingle("zero", "one", "many"); - - Assert.Equal("one", cardinality); - Assert.Equal(10, value); - } - - private sealed class BreakingSingleElementCollection( - T element - ) : ICollection - { - public int Count { get; } = 1; - - public IEnumerator GetEnumerator() - { - yield return element; - throw new InvalidOperationException($"{nameof(SuperEnumerable.TrySingle)} should not have attempted to consume a second element."); - } - - IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - - public void Add(T item) => throw new NotSupportedException(); - public void Clear() => throw new NotSupportedException(); - public bool Contains(T item) => throw new NotSupportedException(); - public void CopyTo(T[] array, int arrayIndex) => throw new NotSupportedException(); - public bool Remove(T item) => throw new NotSupportedException(); - public bool IsReadOnly => true; - } - - [Theory] - [MemberData(nameof(GetSequences), new int[] { 10, 20 })] - public void TrySingleWithMoreThanOne(IDisposableEnumerable seq) - { - using (seq) - { - var (cardinality, value) = seq.TrySingle("zero", "one", "many"); - - Assert.Equal("many", cardinality); - Assert.Null(value); - } - } - - [Fact] - public void TrySingleDoesNotConsumeMoreThanTwoElementsFromTheSequence() - { - using var xs = SuperEnumerable - .From( - () => 1, - () => 2, - BreakingFunc.Of()) - .AsTestingSequence(); - var (cardinality, value) = xs.TrySingle("zero", "one", "many"); - - Assert.Equal("many", cardinality); - Assert.Equal(0, value); - } - - [Theory] - [InlineData(0, "zero")] - [InlineData(1, "one")] - [InlineData(2, "many")] - public void TrySingleEnumeratesOnceOnlyAndDisposes(int numberOfElements, string expectedCardinality) - { - using var seq = Enumerable.Range(1, numberOfElements).AsTestingSequence(); - var (cardinality, _) = seq.TrySingle("zero", "one", "many"); - Assert.Equal(expectedCardinality, cardinality); - } - - [Theory] - [InlineData(0, 0)] - [InlineData(1, 1)] - [InlineData(2, 0)] - public void TrySingleShouldReturnDefaultOrSingleValue(int numberOfElements, int expectedResult) - { - using var seq = Enumerable.Range(1, numberOfElements).AsTestingSequence(); - var result = seq.TrySingle(); - Assert.Equal(expectedResult, result); - } - - public static IEnumerable GetListOfSequences(IEnumerable seq) => - seq.Select(x => (int?)x) - .GetListSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetListOfSequences), new int[] { })] - public void TrySingleShouldReturnWhenProvidedEmptyList(IDisposableEnumerable seq) - { - using (seq) - { - var value = seq.TrySingle(); - Assert.Null(value); - } - } - - [Theory] - [MemberData(nameof(GetListOfSequences), new int[] { 1, 2 })] - public void TrySingleShouldReturnWhenProvidedLongerList(IDisposableEnumerable seq) - { - using (seq) - { - var value = seq.TrySingle(); - Assert.Null(value); - } - } - - [Theory] - [MemberData(nameof(GetListOfSequences), new int[] { 1 })] - public void TrySingleShouldReturnWhenProvidedListWithSingleItem(IDisposableEnumerable seq) - { - using (seq) - { - var value = seq.TrySingle(); - Assert.Equal(1, value); - } - } -} diff --git a/Tests/SuperLinq.Test/.editorconfig b/Tests/SuperLinq.Tests/.editorconfig similarity index 69% rename from Tests/SuperLinq.Test/.editorconfig rename to Tests/SuperLinq.Tests/.editorconfig index 385f3533f..7ce6967b6 100644 --- a/Tests/SuperLinq.Test/.editorconfig +++ b/Tests/SuperLinq.Tests/.editorconfig @@ -1,6 +1,7 @@ [*.cs] dotnet_diagnostic.CA1707.severity = none # CA1707: Identifiers should not contain underscores +dotnet_diagnostic.CA1822.severity = none # CA1822: Mark members as static dotnet_diagnostic.CA1861.severity = none # CA1861: Avoid constant arrays as arguments dotnet_diagnostic.CA2201.severity = none # CA2201: Do not raise reserved exception types @@ -11,9 +12,5 @@ dotnet_diagnostic.CS1573.severity = none # CS1573: Missing XML co dotnet_diagnostic.CS1591.severity = none # CS1591: Missing XML comment for publicly visible type or member dotnet_diagnostic.CS1712.severity = none # CS1712: Type parameter has no matching typeparam tag in the XML comment (but other type parameters do) -# xUnit errors -dotnet_diagnostic.xUnit1008.severity = error # xUnit1008: Test data attribute should only be used on a Theory -dotnet_diagnostic.xUnit1013.severity = error # xUnit1013: Public method should be marked as test -dotnet_diagnostic.xUnit1042.severity = none # xUnit1042: The member referenced by the MemberData attribute returns untyped data rows - dotnet_diagnostic.MA0046.severity = none +dotnet_diagnostic.TUnit0046.severity = none diff --git a/Tests/SuperLinq.Test/AggregateByTest.cs b/Tests/SuperLinq.Tests/AggregateByTest.cs similarity index 56% rename from Tests/SuperLinq.Test/AggregateByTest.cs rename to Tests/SuperLinq.Tests/AggregateByTest.cs index a276fe698..1f4b24143 100644 --- a/Tests/SuperLinq.Test/AggregateByTest.cs +++ b/Tests/SuperLinq.Tests/AggregateByTest.cs @@ -1,146 +1,158 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -namespace Test; +namespace SuperLinq.Tests; -[Obsolete("References `DistinctBy` which is obsolete in net9+")] +[Obsolete("References `AggregateBy` which is obsolete in net9+")] public sealed class AggregateByTest { - [Theory] - [MemberData(nameof(AggregateBy_TestData))] - public static void AggregateBy_HasExpectedOutput( - IEnumerable source, - Func keySelector, - Func seedSelector, - Func func, - IEqualityComparer? comparer, - IEnumerable> expected) where TKey : notnull + [Test] + public static void AggregateBy() { - using var ts = source.AsTestingSequence(); - SuperEnumerable - .AggregateBy(ts, keySelector, seedSelector, func, comparer) - .AssertCollectionEqual(expected); - } - - public static IEnumerable AggregateBy_TestData() - { - yield return WrapArgs( + static void DoTest( + IEnumerable source, + Func keySelector, + Func seedSelector, + Func func, + IEqualityComparer? comparer, + IEnumerable> expected + ) where TKey : notnull + { + using var ts = source.AsTestingSequence(); + SuperEnumerable + .AggregateBy(ts, keySelector, seedSelector, func, comparer) + .AssertCollectionEqual(expected); + } + + DoTest( source: Enumerable.Empty(), keySelector: x => x, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: []); + expected: [] + ); - yield return WrapArgs( + DoTest( source: Enumerable.Range(0, 10), keySelector: x => x, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Range(0, 10).ToDictionary(x => x, x => x)); + expected: Enumerable.Range(0, 10).Select(x => KeyValuePair.Create(x, x)) + ); - yield return WrapArgs( + DoTest( source: Enumerable.Range(5, 10), keySelector: x => true, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Repeat(true, 1).ToDictionary(x => x, x => 95)); + expected: [KeyValuePair.Create(key: true, 95)] + ); - yield return WrapArgs( + DoTest( source: Enumerable.Range(0, 20), keySelector: x => x % 5, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Range(0, 5).ToDictionary(x => x, x => 30 + (4 * x))); + expected: Enumerable.Range(0, 5).Select(x => KeyValuePair.Create(x, 30 + (4 * x))) + ); - yield return WrapArgs( + DoTest( source: Enumerable.Repeat(5, 20), keySelector: x => x, seedSelector: x => 0, func: (x, y) => x + y, comparer: null, - expected: Enumerable.Repeat(5, 1).ToDictionary(x => x, x => 100)); + expected: Enumerable.Repeat(5, 1).Select(x => KeyValuePair.Create(x, 100)) + ); - yield return WrapArgs( + DoTest( source: ["Bob", "bob", "tim", "Bob", "Tim"], keySelector: x => x, seedSelector: x => "", func: (x, y) => x + y, comparer: null, - expected: new Dictionary(StringComparer.Ordinal) - { - { "Bob", "BobBob" }, - { "bob", "bob" }, - { "tim", "tim" }, - { "Tim", "Tim" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create("Bob", "BobBob"), + KeyValuePair.Create("bob", "bob"), + KeyValuePair.Create("tim", "tim"), + KeyValuePair.Create("Tim", "Tim"), + ] + ); + + DoTest( source: ["Bob", "bob", "tim", "Bob", "Tim"], keySelector: x => x, seedSelector: x => "", func: (x, y) => x + y, StringComparer.OrdinalIgnoreCase, - expected: new Dictionary(StringComparer.Ordinal) - { - { "Bob", "BobbobBob" }, - { "tim", "timTim" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create("Bob", "BobbobBob"), + KeyValuePair.Create("tim", "timTim"), + ] + ); + + DoTest( source: new (string Name, int Age)[] { ("Tom", 20), ("Dick", 30), ("Harry", 40) }, keySelector: x => x.Age, seedSelector: x => $"I am {x} and my name is ", func: (x, y) => x + y.Name, comparer: null, - expected: new Dictionary - { - { 20, "I am 20 and my name is Tom" }, - { 30, "I am 30 and my name is Dick" }, - { 40, "I am 40 and my name is Harry" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create(20, "I am 20 and my name is Tom"), + KeyValuePair.Create(30, "I am 30 and my name is Dick"), + KeyValuePair.Create(40, "I am 40 and my name is Harry"), + ] + ); + + DoTest( source: new (string Name, int Age)[] { ("Tom", 20), ("Dick", 20), ("Harry", 40) }, keySelector: x => x.Age, seedSelector: x => $"I am {x} and my name is", func: (x, y) => $"{x} maybe {y.Name}", comparer: null, - expected: new Dictionary - { - { 20, "I am 20 and my name is maybe Tom maybe Dick" }, - { 40, "I am 40 and my name is maybe Harry" }, - }); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create(20, "I am 20 and my name is maybe Tom maybe Dick"), + KeyValuePair.Create(40, "I am 40 and my name is maybe Harry"), + ] + ); + + DoTest( source: new (string Name, int Age)[] { ("Bob", 20), ("bob", 20), ("Harry", 20) }, keySelector: x => x.Name, seedSelector: x => 0, func: (x, y) => x + y.Age, comparer: null, - expected: new string[] { "Bob", "bob", "Harry" } - .ToDictionary(x => x, x => 20, StringComparer.Ordinal)); - - yield return WrapArgs( + expected: + [ + KeyValuePair.Create("Bob", 20), + KeyValuePair.Create("bob", 20), + KeyValuePair.Create("Harry", 20), + ] + ); + + DoTest( source: new (string Name, int Age)[] { ("Bob", 20), ("bob", 30), ("Harry", 40) }, keySelector: x => x.Name, seedSelector: x => 0, func: (x, y) => x + y.Age, comparer: StringComparer.OrdinalIgnoreCase, - expected: new Dictionary(StringComparer.Ordinal) - { - { "Bob", 50 }, - { "Harry", 40 }, - }); - - static object?[] WrapArgs(IEnumerable source, Func keySelector, Func seedSelector, Func func, IEqualityComparer? comparer, IEnumerable> expected) - => [source, keySelector, seedSelector, func, comparer, expected]; + expected: + [ + KeyValuePair.Create("Bob", 50), + KeyValuePair.Create("Harry", 40), + ] + ); } - [Fact] + [Test] public void GroupBy() { static IEnumerable>> GroupBy(IEnumerable source, Func keySelector) @@ -162,7 +174,7 @@ static IEnumerable>> GroupBy(IEn oddsEvens[false].AssertCollectionEqual(1, 3); } - [Fact] + [Test] public void LongCountBy() { static IEnumerable> LongCountBy(IEnumerable source, Func keySelector) @@ -186,7 +198,7 @@ static IEnumerable> LongCountBy(IEnumera }); } - [Fact] + [Test] public void Score() { using var data = TestingSequence.Of<(string id, int score)>( @@ -209,3 +221,18 @@ public void Score() Assert.Equal(4, scores["2"]); } } + +file static class KeyValuePair +{ + /// + /// Creates a new key/value pair instance using provided values. + /// + /// The key of the new to be created. + /// The value of the new to be created. + /// The type of the key. + /// The type of the value. + /// A key/value pair containing the provided arguments as values. + //Link: https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.keyvaluepair.create + public static KeyValuePair Create(TKey key, TValue value) => + new(key, value); +} diff --git a/Tests/SuperLinq.Test/AggregateRightTest.cs b/Tests/SuperLinq.Tests/AggregateRightTest.cs similarity index 92% rename from Tests/SuperLinq.Test/AggregateRightTest.cs rename to Tests/SuperLinq.Tests/AggregateRightTest.cs index 83f6e4909..8836bfb98 100644 --- a/Tests/SuperLinq.Test/AggregateRightTest.cs +++ b/Tests/SuperLinq.Tests/AggregateRightTest.cs @@ -1,17 +1,17 @@ using System.Globalization; -namespace Test; +namespace SuperLinq.Tests; public sealed class AggregateRightTest { - [Fact] + [Test] public void AggregateRightWithEmptySequence() { _ = Assert.Throws( () => Array.Empty().AggregateRight((a, b) => a + b)); } - [Fact] + [Test] public void AggregateRightFuncIsNotInvokedOnSingleElementSequence() { using var enumerable = TestingSequence.Of(1); @@ -20,7 +20,7 @@ public void AggregateRightFuncIsNotInvokedOnSingleElementSequence() Assert.Equal(1, result); } - [Fact] + [Test] public void AggregateRight() { using var enumerable = Enumerable.Range(1, 5).Select(x => x.ToString(CultureInfo.InvariantCulture)).AsTestingSequence(); @@ -29,7 +29,7 @@ public void AggregateRight() Assert.Equal("(1+(2+(3+(4+5))))", result); } - [Fact] + [Test] public void AggregateRightWithList() { var list = Enumerable.Range(1, 5).Select(x => x.ToString(CultureInfo.InvariantCulture)).ToList(); @@ -38,17 +38,17 @@ public void AggregateRightWithList() Assert.Equal("(1+(2+(3+(4+5))))", result); } - [Theory] - [InlineData(5)] - [InlineData("c")] - [InlineData(true)] + [Test] + [Arguments(5)] + [Arguments("c")] + [Arguments(true)] public void AggregateRightSeedWithEmptySequence(object defaultValue) { using var enumerable = TestingSequence.Of(); Assert.Equal(defaultValue, enumerable.AggregateRight(defaultValue, (a, b) => b)); } - [Fact] + [Test] public void AggregateRightSeedFuncIsNotInvokedOnEmptySequence() { using var enumerable = TestingSequence.Of(); @@ -57,7 +57,7 @@ public void AggregateRightSeedFuncIsNotInvokedOnEmptySequence() Assert.Equal(1, result); } - [Fact] + [Test] public void AggregateRightSeed() { using var enumerable = Enumerable.Range(1, 4).AsTestingSequence(); @@ -66,10 +66,10 @@ public void AggregateRightSeed() Assert.Equal("(1+(2+(3+(4+5))))", result); } - [Theory] - [InlineData(5)] - [InlineData("c")] - [InlineData(true)] + [Test] + [Arguments(5)] + [Arguments("c")] + [Arguments(true)] public void AggregateRightResultorWithEmptySequence(object defaultValue) { using var enumerable = TestingSequence.Of(); @@ -78,7 +78,7 @@ public void AggregateRightResultorWithEmptySequence(object defaultValue) Assert.True(result); } - [Fact] + [Test] public void AggregateRightResultor() { using var enumerable = Enumerable.Range(1, 4).AsTestingSequence(); @@ -87,7 +87,7 @@ public void AggregateRightResultor() Assert.Equal("(1+(2+(3+(4+5))))".Length, result); } - [Fact] + [Test] public void AggregateRightResultorWithList() { var list = Enumerable.Range(1, 4).ToList(); diff --git a/Tests/SuperLinq.Test/AggregateTest.cs b/Tests/SuperLinq.Tests/AggregateTest.cs similarity index 93% rename from Tests/SuperLinq.Test/AggregateTest.cs rename to Tests/SuperLinq.Tests/AggregateTest.cs index 50d627171..398bd99ee 100644 --- a/Tests/SuperLinq.Test/AggregateTest.cs +++ b/Tests/SuperLinq.Tests/AggregateTest.cs @@ -2,11 +2,11 @@ using System.Linq.Expressions; using System.Reflection; -namespace Test; +namespace SuperLinq.Tests; public sealed class AggregateTest { - public static IEnumerable AccumulatorsTestSource() => + public static IEnumerable<(MethodInfo method, object[] args, object expected)> AccumulatorsTestSource() => /* Generates an invocation as follows for 2 accumulators: @@ -68,20 +68,21 @@ from pair in pairs select pair) .Concat([resultSelector]) .ToArray(), - Expectation = + Expectation = (object) Enumerable.Repeat(m.Expectation, m.AccumulatorCount) .ToArray(), } into t - select new object[] { t.Method, t.Args, t.Expectation }; + select (t.Method, t.Args, t.Expectation); - [Theory, MemberData(nameof(AccumulatorsTestSource))] + [Test] + [MethodDataSource(nameof(AccumulatorsTestSource))] public void Accumulators(MethodInfo method, object[] args, object expected) { Assert.Equal(expected, method.Invoke(null, args)); } - [Fact] + [Test] public void SevenUniqueAccumulators() { var result = diff --git a/Tests/SuperLinq.Test/AssertCountTest.cs b/Tests/SuperLinq.Tests/AssertCountTest.cs similarity index 86% rename from Tests/SuperLinq.Test/AssertCountTest.cs rename to Tests/SuperLinq.Tests/AssertCountTest.cs index f6d3a69d2..ed3423945 100644 --- a/Tests/SuperLinq.Test/AssertCountTest.cs +++ b/Tests/SuperLinq.Tests/AssertCountTest.cs @@ -1,27 +1,26 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class AssertCountTest { - [Fact] + [Test] public void AssertCountIsLazy() { _ = new BreakingSequence().AssertCount(0); } - [Fact] + [Test] public void AssertCountNegativeCount() { _ = Assert.Throws("count", () => new BreakingSequence().AssertCount(-1)); } - public static IEnumerable GetSequences() => + public static IEnumerable> GetSequences() => Enumerable.Range(1, 10) - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void AssertCountShortSequence(IDisposableEnumerable seq) { using (seq) @@ -32,8 +31,8 @@ public void AssertCountShortSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void AssertCountEqualSequence(IDisposableEnumerable seq) { using (seq) @@ -45,8 +44,8 @@ public void AssertCountEqualSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void AssertCountLongSequence(IDisposableEnumerable seq) { using (seq) @@ -57,7 +56,7 @@ public void AssertCountLongSequence(IDisposableEnumerable seq) } } - [Fact] + [Test] public void AssertCountCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -67,7 +66,7 @@ public void AssertCountCollectionBehavior() result.AssertSequenceEqual(Enumerable.Range(0, 10_000)); } - [Fact] + [Test] public void AssertCountListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -83,7 +82,7 @@ public void AssertCountListBehavior() #endif } - [Fact] + [Test] public void AssertCountUsesCollectionCountAtIterationTime() { var stack = new Stack(Enumerable.Range(1, 3)); diff --git a/Tests/SuperLinq.Test/AtLeastTest.cs b/Tests/SuperLinq.Tests/AtLeastTest.cs similarity index 67% rename from Tests/SuperLinq.Test/AtLeastTest.cs rename to Tests/SuperLinq.Tests/AtLeastTest.cs index bc19e54ab..ae3d07c5a 100644 --- a/Tests/SuperLinq.Test/AtLeastTest.cs +++ b/Tests/SuperLinq.Tests/AtLeastTest.cs @@ -1,84 +1,79 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class AtLeastTest { - [Fact] + [Test] public void AtLeastWithNegativeCount() { _ = Assert.Throws(() => new BreakingSequence().AtLeast(-1)); } - public static IEnumerable GetSequences(IEnumerable seq) => - seq - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetEmptySequences))] public void AtLeastWithEmptySequenceHasAtLeastZeroElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtLeast(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetEmptySequences))] public void AtLeastWithEmptySequenceHasAtLeastOneElement(IDisposableEnumerable seq) { using (seq) Assert.False(seq.AtLeast(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void AtLeastWithSingleElementHasAtLeastZeroElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtLeast(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void AtLeastWithSingleElementHasAtLeastOneElement(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtLeast(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void AtLeastWithSingleElementHasAtLeastManyElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.AtLeast(2)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void AtLeastWithManyElementsHasAtLeastZeroElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtLeast(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void AtLeastWithManyElementsHasAtLeastOneElement(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtLeast(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void AtLeastWithManyElementsHasAtLeastManyElement(IDisposableEnumerable seq) { using (seq) Assert.False(seq.AtLeast(4)); } - [Fact] + [Test] public void AtLeastDoesNotIterateUnnecessaryElements() { using var source = SeqExceptionAt(3).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/AtMostTest.cs b/Tests/SuperLinq.Tests/AtMostTest.cs similarity index 67% rename from Tests/SuperLinq.Test/AtMostTest.cs rename to Tests/SuperLinq.Tests/AtMostTest.cs index 16ffb3135..383785c53 100644 --- a/Tests/SuperLinq.Test/AtMostTest.cs +++ b/Tests/SuperLinq.Tests/AtMostTest.cs @@ -1,84 +1,79 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class AtMostTest { - [Fact] + [Test] public void AtMostWithNegativeCount() { _ = Assert.Throws(() => new BreakingSequence().AtMost(-1)); } - public static IEnumerable GetSequences(IEnumerable seq) => - seq - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetEmptySequences))] public void AtMostWithEmptySequenceHasAtMostZeroElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtMost(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetEmptySequences))] public void AtMostWithEmptySequenceHasAtMostOneElement(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtMost(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void AtMostWithSingleElementHasAtMostZeroElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.AtMost(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void AtMostWithSingleElementHasAtMostOneElement(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtMost(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void AtMostWithSingleElementHasAtMostManyElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtMost(2)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void AtMostWithManyElementsHasAtMostZeroElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.AtMost(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void AtMostWithManyElementsHasAtMostOneElement(IDisposableEnumerable seq) { using (seq) Assert.False(seq.AtMost(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void AtMostWithManyElementsHasAtMostManyElement(IDisposableEnumerable seq) { using (seq) Assert.True(seq.AtMost(4)); } - [Fact] + [Test] public void AtMostDoesNotIterateUnnecessaryElements() { using var source = SeqExceptionAt(4).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/BacksertTest.cs b/Tests/SuperLinq.Tests/BacksertTest.cs similarity index 70% rename from Tests/SuperLinq.Test/BacksertTest.cs rename to Tests/SuperLinq.Tests/BacksertTest.cs index 60d3674f7..03e852356 100644 --- a/Tests/SuperLinq.Test/BacksertTest.cs +++ b/Tests/SuperLinq.Tests/BacksertTest.cs @@ -1,25 +1,25 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; [Obsolete("References `Backsert` which is obsolete in favor of `Insert`")] public sealed class BacksertTest { - [Fact] + [Test] public void BacksertIsLazy() { _ = new BreakingSequence().Backsert(new BreakingSequence(), 0); } - [Fact] + [Test] public void BacksertWithNegativeIndex() { _ = Assert.Throws(() => new BreakingSequence().Backsert([97, 98, 99], -1)); } - [Theory] - [InlineData(new[] { 1, 2, 3 }, 4, new[] { 9 })] + [Test] + [Arguments(new[] { 1, 2, 3 }, 4, new[] { 9 })] public void BacksertWithIndexGreaterThanSourceLength(int[] seq1, int index, int[] seq2) { using var test1 = seq1.AsTestingSequence(); @@ -30,11 +30,11 @@ public void BacksertWithIndexGreaterThanSourceLength(int[] seq1, int index, int[ _ = Assert.Throws(() => result.ElementAt(0)); } - [Theory] - [InlineData(new[] { 1, 2, 3 }, 0, new[] { 8, 9 }, new[] { 1, 2, 3, 8, 9 })] - [InlineData(new[] { 1, 2, 3 }, 1, new[] { 8, 9 }, new[] { 1, 2, 8, 9, 3 })] - [InlineData(new[] { 1, 2, 3 }, 2, new[] { 8, 9 }, new[] { 1, 8, 9, 2, 3 })] - [InlineData(new[] { 1, 2, 3 }, 3, new[] { 8, 9 }, new[] { 8, 9, 1, 2, 3 })] + [Test] + [Arguments(new[] { 1, 2, 3 }, 0, new[] { 8, 9 }, new[] { 1, 2, 3, 8, 9 })] + [Arguments(new[] { 1, 2, 3 }, 1, new[] { 8, 9 }, new[] { 1, 2, 8, 9, 3 })] + [Arguments(new[] { 1, 2, 3 }, 2, new[] { 8, 9 }, new[] { 1, 8, 9, 2, 3 })] + [Arguments(new[] { 1, 2, 3 }, 3, new[] { 8, 9 }, new[] { 8, 9, 1, 2, 3 })] public void Backsert(int[] seq1, int index, int[] seq2, int[] expected) { using var test1 = seq1.AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/BatchTest.cs b/Tests/SuperLinq.Tests/BatchTest.cs similarity index 66% rename from Tests/SuperLinq.Test/BatchTest.cs rename to Tests/SuperLinq.Tests/BatchTest.cs index be6e56fc2..7e506e635 100644 --- a/Tests/SuperLinq.Test/BatchTest.cs +++ b/Tests/SuperLinq.Tests/BatchTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class BatchTest { - [Fact] + [Test] public void BatchIsLazy() { _ = new BreakingSequence().Batch(1); @@ -16,7 +16,7 @@ public void BatchIsLazy() .Batch(new int[2], 1, BreakingReadOnlySpanFunc.Of()); } - [Fact] + [Test] public void BatchValidatesSize() { _ = Assert.Throws("size", @@ -39,13 +39,12 @@ public void BatchValidatesSize() .Batch(new int[5], 5, BreakingReadOnlySpanFunc.Of()); } - public static IEnumerable GetFourElementSequences() => + public static IEnumerable> GetFourElementSequences() => Enumerable.Range(0, 4) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetFourElementSequences))] + [Test] + [MethodDataSource(nameof(GetFourElementSequences))] public void BatchDoesNotReturnSameArrayInstance(IDisposableEnumerable seq) { using (seq) @@ -61,8 +60,8 @@ public void BatchDoesNotReturnSameArrayInstance(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetFourElementSequences))] + [Test] + [MethodDataSource(nameof(GetFourElementSequences))] public void BatchModifiedBeforeMoveNextDoesNotAffectNextBatch(IDisposableEnumerable seq) { using (seq) @@ -79,8 +78,8 @@ public void BatchModifiedBeforeMoveNextDoesNotAffectNextBatch(IDisposableEnumera } } - [Theory] - [MemberData(nameof(GetFourElementSequences))] + [Test] + [MethodDataSource(nameof(GetFourElementSequences))] public void BatchModifiedAfterMoveNextDoesNotAffectNextBatch(IDisposableEnumerable seq) { using (seq) @@ -97,8 +96,8 @@ public void BatchModifiedAfterMoveNextDoesNotAffectNextBatch(IDisposableEnumerab } } - [Theory] - [MemberData(nameof(GetFourElementSequences))] + [Test] + [MethodDataSource(nameof(GetFourElementSequences))] public void BatchModifiedDoesNotAffectPreviousBatch(IDisposableEnumerable seq) { using (seq) @@ -123,14 +122,14 @@ public enum BatchMethod BufferSizeArray, } - private static IEnumerable GetBatchTestSequences(IEnumerable source) + private static IEnumerable<(IDisposableEnumerable seq, BatchMethod bm)> GetBatchTestSequences(IEnumerable source) { foreach (var seq in source.GetListSequences()) - yield return new object[] { seq, BatchMethod.Traditional }; + yield return (seq, BatchMethod.Traditional); - yield return new object[] { source.AsTestingSequence(), BatchMethod.BufferSize }; - yield return new object[] { source.AsTestingSequence(), BatchMethod.BufferArray }; - yield return new object[] { source.AsTestingSequence(), BatchMethod.BufferSizeArray }; + yield return (source.AsTestingSequence(), BatchMethod.BufferSize); + yield return (source.AsTestingSequence(), BatchMethod.BufferArray); + yield return (source.AsTestingSequence(), BatchMethod.BufferSizeArray); } private static IEnumerable> GetBatches( @@ -146,30 +145,30 @@ private static IEnumerable> GetBatches( _ => throw new NotSupportedException(), }; - public static IEnumerable GetEmptySequences() => + public static IEnumerable<(IDisposableEnumerable, BatchMethod)> GetEmptySequences() => GetBatchTestSequences([]); - [Theory] - [MemberData(nameof(GetEmptySequences))] - public void BatchWithEmptySource(IDisposableEnumerable seq, BatchMethod bm) + [Test] + [MethodDataSource(nameof(GetEmptySequences))] + public void BatchWithEmptySource(IDisposableEnumerable seq, BatchMethod batchMethod) { using (seq) { - var result = GetBatches(seq, bm, 5); + var result = GetBatches(seq, batchMethod, 5); result.AssertSequenceEqual(); } } - public static IEnumerable GetSequences() => + public static IEnumerable<(IDisposableEnumerable, BatchMethod)> GetSequences() => GetBatchTestSequences(Enumerable.Range(1, 9)); - [Theory] - [MemberData(nameof(GetSequences))] - public void BatchEvenlyDivisibleSequence(IDisposableEnumerable seq, BatchMethod bm) + [Test] + [MethodDataSource(nameof(GetSequences))] + public void BatchEvenlyDivisibleSequence(IDisposableEnumerable seq, BatchMethod batchMethod) { using (seq) { - var result = GetBatches(seq, bm, 3); + var result = GetBatches(seq, batchMethod, 3); result.AssertSequenceEqual( [1, 2, 3], [4, 5, 6], @@ -177,13 +176,13 @@ public void BatchEvenlyDivisibleSequence(IDisposableEnumerable seq, BatchMe } } - [Theory] - [MemberData(nameof(GetSequences))] - public void BatchUnevenlyDivisibleSequence(IDisposableEnumerable seq, BatchMethod bm) + [Test] + [MethodDataSource(nameof(GetSequences))] + public void BatchUnevenlyDivisibleSequence(IDisposableEnumerable seq, BatchMethod batchMethod) { using (seq) { - var result = GetBatches(seq, bm, 4); + var result = GetBatches(seq, batchMethod, 4); result.AssertSequenceEqual( [1, 2, 3, 4], [5, 6, 7, 8], @@ -191,54 +190,60 @@ public void BatchUnevenlyDivisibleSequence(IDisposableEnumerable seq, Batch } } - [Theory] - [MemberData(nameof(GetSequences))] - public void BatchSmallSequence(IDisposableEnumerable seq, BatchMethod bm) + [Test] + [MethodDataSource(nameof(GetSequences))] + public void BatchSmallSequence(IDisposableEnumerable seq, BatchMethod batchMethod) { using (seq) { - var result = GetBatches(seq, bm, 10); + var result = GetBatches(seq, batchMethod, 10); result.AssertSequenceEqual( [1, 2, 3, 4, 5, 6, 7, 8, 9]); } } - public static IEnumerable GetBreakingCollections(IEnumerable source) + private static IEnumerable<(IDisposableEnumerable, BatchMethod)> GetBreakingCollections(IEnumerable source) { - yield return new object[] { source.AsBreakingCollection(), BatchMethod.Traditional }; - yield return new object[] { source.AsBreakingCollection(), BatchMethod.BufferSize }; - yield return new object[] { source.AsBreakingCollection(), BatchMethod.BufferArray }; - yield return new object[] { source.AsBreakingCollection(), BatchMethod.BufferSizeArray }; + yield return (source.AsBreakingCollection(), BatchMethod.Traditional); + yield return (source.AsBreakingCollection(), BatchMethod.BufferSize); + yield return (source.AsBreakingCollection(), BatchMethod.BufferArray); + yield return (source.AsBreakingCollection(), BatchMethod.BufferSizeArray); } - [Theory] - [MemberData(nameof(GetBreakingCollections), new int[] { })] - public void BatchWithEmptyCollection(IDisposableEnumerable seq, BatchMethod bm) + public static IEnumerable<(IDisposableEnumerable, BatchMethod)> GetEmptyBreakingCollections() => + GetBreakingCollections([]); + + [Test] + [MethodDataSource(nameof(GetEmptyBreakingCollections))] + public void BatchWithEmptyCollection(IDisposableEnumerable seq, BatchMethod batchMethod) { using (seq) { - var result = GetBatches(seq, bm, 10); + var result = GetBatches(seq, batchMethod, 10); result.AssertSequenceEqual(); } } - [Theory] - [MemberData(nameof(GetBreakingCollections), new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 })] - public void BatchWithCollectionSmallerThanBatchSize(IDisposableEnumerable seq, BatchMethod bm) + public static IEnumerable<(IDisposableEnumerable, BatchMethod)> GetNonEmptyBreakingCollections() => + GetBreakingCollections(Enumerable.Range(1, 9)); + + [Test] + [MethodDataSource(nameof(GetNonEmptyBreakingCollections))] + public void BatchWithCollectionSmallerThanBatchSize(IDisposableEnumerable seq, BatchMethod batchMethod) { using (seq) { - var result = GetBatches(seq, bm, 10); + var result = GetBatches(seq, batchMethod, 10); result.AssertSequenceEqual( [1, 2, 3, 4, 5, 6, 7, 8, 9]); } } - [Theory] - [InlineData(BatchMethod.Traditional)] - [InlineData(BatchMethod.BufferSize)] - [InlineData(BatchMethod.BufferArray)] - [InlineData(BatchMethod.BufferSizeArray)] + [Test] + [Arguments(BatchMethod.Traditional)] + [Arguments(BatchMethod.BufferSize)] + [Arguments(BatchMethod.BufferArray)] + [Arguments(BatchMethod.BufferSizeArray)] public void BatchCollectionSizeNotEvaluatedEarly(BatchMethod bm) { var list = new List() { 1, 2, 3 }; @@ -247,11 +252,11 @@ public void BatchCollectionSizeNotEvaluatedEarly(BatchMethod bm) result.AssertCount(2).Consume(); } - [Theory] - [InlineData(BatchMethod.Traditional)] - [InlineData(BatchMethod.BufferSize)] - [InlineData(BatchMethod.BufferArray)] - [InlineData(BatchMethod.BufferSizeArray)] + [Test] + [Arguments(BatchMethod.Traditional)] + [Arguments(BatchMethod.BufferSize)] + [Arguments(BatchMethod.BufferArray)] + [Arguments(BatchMethod.BufferSizeArray)] public void BatchUsesCollectionCountAtIterationTime(BatchMethod bm) { var list = new List(Enumerable.Range(1, 3)); @@ -268,7 +273,7 @@ public void BatchUsesCollectionCountAtIterationTime(BatchMethod bm) () => result.AssertCount(2).Consume()); } - [Fact] + [Test] public void BatchListEvenlyDivisibleBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -284,7 +289,7 @@ public void BatchListEvenlyDivisibleBehavior() #endif } - [Fact] + [Test] public void BatchListUnevenlyDivisibleBehavior() { using var seq = Enumerable.Range(0, 10_002).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/BindByIndexTest.cs b/Tests/SuperLinq.Tests/BindByIndexTest.cs similarity index 94% rename from Tests/SuperLinq.Test/BindByIndexTest.cs rename to Tests/SuperLinq.Tests/BindByIndexTest.cs index 57d3f436f..860705fd3 100644 --- a/Tests/SuperLinq.Test/BindByIndexTest.cs +++ b/Tests/SuperLinq.Tests/BindByIndexTest.cs @@ -1,15 +1,15 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class BindByIndexTest { - [Fact] + [Test] public void BindByIndexIsLazy() { _ = new BreakingSequence().BindByIndex(new BreakingSequence()); _ = new BreakingSequence().BindByIndex(new BreakingSequence(), BreakingFunc.Of(), BreakingFunc.Of()); } - [Fact] + [Test] public void BindByIndexDisposesEnumerators() { using var seq1 = TestingSequence.Of(); @@ -17,7 +17,7 @@ public void BindByIndexDisposesEnumerators() Assert.Empty(seq1.BindByIndex(seq2)); } - [Fact] + [Test] public void BindByIndexInOrder() { var indexes = Seq(1, 3, 5, 7, 9); @@ -27,7 +27,7 @@ public void BindByIndexInOrder() seq1.BindByIndex(seq2).AssertSequenceEqual(indexes.Select(x => x + 1)); } - [Fact] + [Test] public void BindByIndexOutOfOrder() { var indexes = Seq(9, 7, 5, 3, 1); @@ -37,7 +37,7 @@ public void BindByIndexOutOfOrder() seq1.BindByIndex(seq2).AssertSequenceEqual(indexes.Select(x => x + 1)); } - [Fact] + [Test] public void BindByIndexComplex() { var indexes = Seq(0, 1, 8, 9, 3, 4, 2); @@ -47,10 +47,10 @@ public void BindByIndexComplex() seq1.BindByIndex(seq2).AssertSequenceEqual(indexes.Select(x => x + 1)); } - [Theory] - [InlineData(-1)] - [InlineData(10)] - [InlineData(100)] + [Test] + [Arguments(-1)] + [Arguments(10)] + [Arguments(100)] public void BindByIndexThrowExceptionInvalidIndex(int index) { using var seq1 = Enumerable.Range(1, 10).AsTestingSequence(); @@ -60,7 +60,7 @@ public void BindByIndexThrowExceptionInvalidIndex(int index) seq1.BindByIndex(seq2).Consume()); } - [Fact] + [Test] public void BindByIndexTransformInOrder() { var indexes = Seq(1, 3, 5, 7, 9); @@ -71,7 +71,7 @@ public void BindByIndexTransformInOrder() .AssertSequenceEqual(indexes.Select(x => (int?)(x + 1))); } - [Fact] + [Test] public void BindByIndexTransformOutOfOrder() { var indexes = Seq(9, 7, 5, 3, 1); @@ -82,7 +82,7 @@ public void BindByIndexTransformOutOfOrder() .AssertSequenceEqual(indexes.Select(x => (int?)(x + 1))); } - [Fact] + [Test] public void BindByIndexTransformComplex() { var indexes = Seq(0, 1, 8, 9, 3, 4, 2); @@ -93,7 +93,7 @@ public void BindByIndexTransformComplex() .AssertSequenceEqual(indexes.Select(x => (int?)(x + 1))); } - [Fact] + [Test] public void BindByIndexTransformInvalidIndex() { using var seq1 = Enumerable.Range(1, 10).AsTestingSequence(); @@ -103,7 +103,7 @@ public void BindByIndexTransformInvalidIndex() .AssertSequenceEqual(2, null, 4, null); } - [Fact] + [Test] public void BindByIndexTransformThrowExceptionNegativeIndex() { using var seq1 = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/BreakingAction.cs b/Tests/SuperLinq.Tests/BreakingAction.cs similarity index 95% rename from Tests/SuperLinq.Test/BreakingAction.cs rename to Tests/SuperLinq.Tests/BreakingAction.cs index eff2d8d94..d80e67907 100644 --- a/Tests/SuperLinq.Test/BreakingAction.cs +++ b/Tests/SuperLinq.Tests/BreakingAction.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Functions which throw NotImplementedException if they're ever called. diff --git a/Tests/SuperLinq.Test/BreakingCollection.cs b/Tests/SuperLinq.Tests/BreakingCollection.cs similarity index 97% rename from Tests/SuperLinq.Test/BreakingCollection.cs rename to Tests/SuperLinq.Tests/BreakingCollection.cs index 721bbac9a..b0b9b0e3c 100644 --- a/Tests/SuperLinq.Test/BreakingCollection.cs +++ b/Tests/SuperLinq.Tests/BreakingCollection.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; internal static class BreakingCollection { diff --git a/Tests/SuperLinq.Test/BreakingFunc.cs b/Tests/SuperLinq.Tests/BreakingFunc.cs similarity index 96% rename from Tests/SuperLinq.Test/BreakingFunc.cs rename to Tests/SuperLinq.Tests/BreakingFunc.cs index 59243a26f..5f171a121 100644 --- a/Tests/SuperLinq.Test/BreakingFunc.cs +++ b/Tests/SuperLinq.Tests/BreakingFunc.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Functions which throw NotImplementedException if they're ever called. diff --git a/Tests/SuperLinq.Test/BreakingList.cs b/Tests/SuperLinq.Tests/BreakingList.cs similarity index 98% rename from Tests/SuperLinq.Test/BreakingList.cs rename to Tests/SuperLinq.Tests/BreakingList.cs index 937bb6584..a711b93c6 100644 --- a/Tests/SuperLinq.Test/BreakingList.cs +++ b/Tests/SuperLinq.Tests/BreakingList.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; internal static class BreakingList { diff --git a/Tests/SuperLinq.Test/BreakingReadOnlySpanFunc.cs b/Tests/SuperLinq.Tests/BreakingReadOnlySpanFunc.cs similarity index 90% rename from Tests/SuperLinq.Test/BreakingReadOnlySpanFunc.cs rename to Tests/SuperLinq.Tests/BreakingReadOnlySpanFunc.cs index e05ec3b99..2817c36a1 100644 --- a/Tests/SuperLinq.Test/BreakingReadOnlySpanFunc.cs +++ b/Tests/SuperLinq.Tests/BreakingReadOnlySpanFunc.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Functions which throw NotImplementedException if they're ever called. diff --git a/Tests/SuperLinq.Test/BreakingSequence.cs b/Tests/SuperLinq.Tests/BreakingSequence.cs similarity index 93% rename from Tests/SuperLinq.Test/BreakingSequence.cs rename to Tests/SuperLinq.Tests/BreakingSequence.cs index 25550e311..2d8d50828 100644 --- a/Tests/SuperLinq.Test/BreakingSequence.cs +++ b/Tests/SuperLinq.Tests/BreakingSequence.cs @@ -1,6 +1,6 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; /// /// Enumerable sequence which throws InvalidOperationException as soon as its diff --git a/Tests/SuperLinq.Test/BufferTest.cs b/Tests/SuperLinq.Tests/BufferTest.cs similarity index 92% rename from Tests/SuperLinq.Test/BufferTest.cs rename to Tests/SuperLinq.Tests/BufferTest.cs index e76046ee7..21fb99d7e 100644 --- a/Tests/SuperLinq.Test/BufferTest.cs +++ b/Tests/SuperLinq.Tests/BufferTest.cs @@ -1,28 +1,28 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class BufferTest { - [Fact] + [Test] public void BufferIsLazy() { _ = new BreakingSequence().Buffer(2, 1); } - [Fact] + [Test] public void BufferValidatesCount() { _ = Assert.Throws("count", () => new BreakingSequence().Buffer(0, 2)); } - [Fact] + [Test] public void BufferValidatesSkip() { _ = Assert.Throws("skip", () => new BreakingSequence().Buffer(2, 0)); } - [Fact] + [Test] public void BufferEmptySequence() { using var seq = Enumerable.Empty().AsTestingSequence(); @@ -31,10 +31,10 @@ public void BufferEmptySequence() result.AssertSequenceEqual(); } - [Theory] - [InlineData(3)] - [InlineData(5)] - [InlineData(7)] + [Test] + [Arguments(3)] + [Arguments(5)] + [Arguments(7)] public void BufferNonOverlappingBuffers(int count) { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -44,7 +44,7 @@ public void BufferNonOverlappingBuffers(int count) actual.AssertSequenceEqual(expected); } - [Fact] + [Test] public void BufferOverlappingBuffers() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -58,7 +58,7 @@ public void BufferOverlappingBuffers() reader.ReadEnd(); } - [Fact] + [Test] public void BufferSkippingBuffers() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/CartesianTest.cs b/Tests/SuperLinq.Tests/CartesianTest.cs similarity index 98% rename from Tests/SuperLinq.Test/CartesianTest.cs rename to Tests/SuperLinq.Tests/CartesianTest.cs index 5a7c5bec7..242b06c82 100644 --- a/Tests/SuperLinq.Test/CartesianTest.cs +++ b/Tests/SuperLinq.Tests/CartesianTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Cartesian operator @@ -8,7 +8,7 @@ public sealed class CartesianTests /// /// Verify that the Cartesian product is evaluated in a lazy fashion on demand. /// - [Fact] + [Test] public void TestCartesianIsLazy() { _ = new BreakingSequence() @@ -21,7 +21,7 @@ public void TestCartesianIsLazy() /// /// Verify that the Cartesian product of two empty sequences is an empty sequence /// - [Fact] + [Test] public void TestCartesianOfEmptySequences() { using var sequenceA = Enumerable.Empty().AsTestingSequence(); @@ -35,7 +35,7 @@ public void TestCartesianOfEmptySequences() /// /// Verify that the Cartesian product of an empty and non-empty sequence is an empty sequence /// - [Fact] + [Test] public void TestCartesianOfEmptyAndNonEmpty() { var sequenceA = Enumerable.Empty(); @@ -59,7 +59,7 @@ public void TestCartesianOfEmptyAndNonEmpty() /// /// Verify that the number of elements in a Cartesian product is the product of the number of elements of each sequence /// - [Fact] + [Test] public void TestCartesianProductCount() { using var sequenceA = Enumerable.Range(1, 100).AsTestingSequence(); @@ -74,7 +74,7 @@ public void TestCartesianProductCount() /// Verify that the number of elements in a Cartesian product is the product of the number of elements of each sequence, /// even when there are more than two sequences /// - [Fact] + [Test] public void TestCartesianProductCountMultidimensional() { const int CountA = 10; @@ -96,7 +96,7 @@ public void TestCartesianProductCountMultidimensional() /// /// Verify that each combination is produced in the Cartesian product /// - [Fact] + [Test] public void TestCartesianProductCombinations() { var sequenceA = Enumerable.Range(0, 5); @@ -128,7 +128,7 @@ public void TestCartesianProductCombinations() Assert.True(expectedSet.SelectMany(SuperEnumerable.Identity).All(SuperEnumerable.Identity)); } - [Fact] + [Test] public void TestAllCartesianMethods() { using var ts1 = Enumerable.Range(0, 1).AsTestingSequence(maxEnumerations: 7); diff --git a/Tests/SuperLinq.Test/CaseTest.cs b/Tests/SuperLinq.Tests/CaseTest.cs similarity index 95% rename from Tests/SuperLinq.Test/CaseTest.cs rename to Tests/SuperLinq.Tests/CaseTest.cs index f259241ae..82d5e90ab 100644 --- a/Tests/SuperLinq.Test/CaseTest.cs +++ b/Tests/SuperLinq.Tests/CaseTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class CaseTest { - [Fact] + [Test] public void CaseIsLazy() { _ = SuperEnumerable.Case(BreakingFunc.Of(), new Dictionary>()); } - [Fact] + [Test] public void CaseBehavior() { var starts = 0; @@ -34,13 +34,13 @@ public void CaseBehavior() seq.AssertSequenceEqual(); } - [Fact] + [Test] public void CaseSourceIsLazy() { _ = SuperEnumerable.Case(BreakingFunc.Of(), new Dictionary>(), new BreakingSequence()); } - [Fact] + [Test] public void CaseSourceBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Test/CatchTest.cs b/Tests/SuperLinq.Tests/CatchTest.cs similarity index 94% rename from Tests/SuperLinq.Test/CatchTest.cs rename to Tests/SuperLinq.Tests/CatchTest.cs index 3948b5cc9..b2c0fac3e 100644 --- a/Tests/SuperLinq.Test/CatchTest.cs +++ b/Tests/SuperLinq.Tests/CatchTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class CatchTest { - [Fact] + [Test] public void CatchIsLazy() { _ = new BreakingSequence().Catch(BreakingFunc.Of>()); @@ -11,14 +11,14 @@ public void CatchIsLazy() _ = new[] { new BreakingSequence(), new BreakingSequence() }.Catch(); } - [Fact] + [Test] public void CatchThrowsDelayedExceptionOnNullSource() { var seq = SuperEnumerable.Catch(new IEnumerable[] { null! }); _ = Assert.Throws(seq.Consume); } - [Fact] + [Test] public void CatchHandlerWithNoExceptions() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -27,7 +27,7 @@ public void CatchHandlerWithNoExceptions() result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public void CatchHandlerWithException() { using var seq = SeqExceptionAt(5).AsTestingSequence(); @@ -45,7 +45,7 @@ public void CatchHandlerWithException() Assert.True(ran); } - [Fact] + [Test] public void CatchWithEmptySequenceList() { using var seq = Enumerable.Empty>().AsTestingSequence(); @@ -54,10 +54,10 @@ public void CatchWithEmptySequenceList() result.AssertSequenceEqual(); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] public void CatchMultipleSequencesNoExceptions(int count) { using var ts1 = Enumerable.Range(1, 10).AsTestingSequence(); @@ -74,10 +74,10 @@ public void CatchMultipleSequencesNoExceptions(int count) result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Theory] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] + [Test] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] public void CatchMultipleSequencesWithNoExceptionOnSequence(int sequenceNumber) { var cnt = 1; @@ -97,7 +97,7 @@ public void CatchMultipleSequencesWithNoExceptionOnSequence(int sequenceNumber) .Concat(Enumerable.Range(1, 10))); } - [Fact] + [Test] public void CatchMultipleSequencesThrowsIfNoFollowingSequence() { using var ts1 = SeqExceptionAt(5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ChooseTest.cs b/Tests/SuperLinq.Tests/ChooseTest.cs similarity index 94% rename from Tests/SuperLinq.Test/ChooseTest.cs rename to Tests/SuperLinq.Tests/ChooseTest.cs index 7012e4f01..7af544300 100644 --- a/Tests/SuperLinq.Test/ChooseTest.cs +++ b/Tests/SuperLinq.Tests/ChooseTest.cs @@ -1,31 +1,31 @@ using System.Globalization; -namespace Test; +namespace SuperLinq.Tests; public sealed class ChooseTest { - [Fact] + [Test] public void IsLazy() { _ = new BreakingSequence() .Choose(BreakingFunc.Of()); } - [Fact] + [Test] public void WithEmptySource() { using var xs = TestingSequence.Of(); Assert.Empty(xs.Choose(BreakingFunc.Of())); } - [Fact] + [Test] public void None() { using var xs = Enumerable.Range(1, 10).AsTestingSequence(); Assert.Empty(xs.Choose(_ => (false, 0))); } - [Fact] + [Test] public void ThoseParsable() { using var xs = @@ -40,7 +40,7 @@ public void ThoseParsable() .AssertSequenceEqual(2, 3, 4, 6, 7, 9); } - [Fact] + [Test] public void ThoseThatAreIntegers() { using var xs = TestingSequence.Of(4, 1, 2, null, 4, null, 6, null, null, 9); @@ -49,7 +49,7 @@ public void ThoseThatAreIntegers() .AssertSequenceEqual(4, 1, 2, 4, 6, 9); } - [Fact] + [Test] public void ThoseEven() { using var xs = Enumerable.Range(1, 10) diff --git a/Tests/SuperLinq.Test/CollectionEqualTest.cs b/Tests/SuperLinq.Tests/CollectionEqualTest.cs similarity index 96% rename from Tests/SuperLinq.Test/CollectionEqualTest.cs rename to Tests/SuperLinq.Tests/CollectionEqualTest.cs index 17b768909..d11b408c2 100644 --- a/Tests/SuperLinq.Test/CollectionEqualTest.cs +++ b/Tests/SuperLinq.Tests/CollectionEqualTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class CollectionEqualTest { - [Fact] + [Test] public void CollectionEqualIntSequenceInOrder() { using var xs = TestingSequence.Of(1, 2, 3); @@ -10,7 +10,7 @@ public void CollectionEqualIntSequenceInOrder() Assert.True(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualIntSequenceOutOfOrder() { using var xs = TestingSequence.Of(1, 2, 3); @@ -18,7 +18,7 @@ public void CollectionEqualIntSequenceOutOfOrder() Assert.True(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualIntSequenceDuplicate() { using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -26,7 +26,7 @@ public void CollectionEqualIntSequenceDuplicate() Assert.True(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualIntDifferentSequence() { using var xs = TestingSequence.Of(1, 2, 3); @@ -34,7 +34,7 @@ public void CollectionEqualIntDifferentSequence() Assert.False(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualIntDifferentDuplicate() { using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -42,7 +42,7 @@ public void CollectionEqualIntDifferentDuplicate() Assert.False(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualStringSequenceInOrder() { using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -50,7 +50,7 @@ public void CollectionEqualStringSequenceInOrder() Assert.True(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualStringSequenceOutOfOrder() { using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -58,7 +58,7 @@ public void CollectionEqualStringSequenceOutOfOrder() Assert.True(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualStringSequenceDuplicate() { using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); @@ -66,7 +66,7 @@ public void CollectionEqualStringSequenceDuplicate() Assert.True(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualStringDifferentSequence() { using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -74,7 +74,7 @@ public void CollectionEqualStringDifferentSequence() Assert.False(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualStringDifferentDuplicate() { using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); @@ -82,7 +82,7 @@ public void CollectionEqualStringDifferentDuplicate() Assert.False(xs.CollectionEqual(ys)); } - [Fact] + [Test] public void CollectionEqualIntSequenceInOrderComparer() { using var xs = TestingSequence.Of(1, 2, 3); @@ -91,7 +91,7 @@ public void CollectionEqualIntSequenceInOrderComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public void CollectionEqualIntSequenceOutOfOrderComparer() { using var xs = TestingSequence.Of(1, 2, 3); @@ -100,7 +100,7 @@ public void CollectionEqualIntSequenceOutOfOrderComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public void CollectionEqualIntSequenceDuplicateComparer() { using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -109,7 +109,7 @@ public void CollectionEqualIntSequenceDuplicateComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public void CollectionEqualIntDifferentSequenceComparer() { using var xs = TestingSequence.Of(1, 2, 3); @@ -118,7 +118,7 @@ public void CollectionEqualIntDifferentSequenceComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public void CollectionEqualIntDifferentDuplicateComparer() { using var xs = TestingSequence.Of(1, 1, 2, 2, 3, 3); @@ -127,7 +127,7 @@ public void CollectionEqualIntDifferentDuplicateComparer() ys, EqualityComparer.Create((a, b) => Math.Abs(a) == Math.Abs(b), x => Math.Abs(x).GetHashCode()))); } - [Fact] + [Test] public void CollectionEqualStringSequenceInOrderComparer() { using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -135,7 +135,7 @@ public void CollectionEqualStringSequenceInOrderComparer() Assert.True(xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public void CollectionEqualStringSequenceOutOfOrderComparer() { using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -143,7 +143,7 @@ public void CollectionEqualStringSequenceOutOfOrderComparer() Assert.True(xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public void CollectionEqualStringSequenceDuplicateComparer() { using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); @@ -151,7 +151,7 @@ public void CollectionEqualStringSequenceDuplicateComparer() Assert.True(xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public void CollectionEqualStringDifferentSequenceComparer() { using var xs = TestingSequence.Of("foo", "bar", "qux"); @@ -159,7 +159,7 @@ public void CollectionEqualStringDifferentSequenceComparer() Assert.False(xs.CollectionEqual(ys, StringComparer.OrdinalIgnoreCase)); } - [Fact] + [Test] public void CollectionEqualStringDifferentDuplicateComparer() { using var xs = TestingSequence.Of("foo", "foo", "bar", "bar", "qux", "qux"); diff --git a/Tests/SuperLinq.Test/Combinatorics.cs b/Tests/SuperLinq.Tests/Combinatorics.cs similarity index 89% rename from Tests/SuperLinq.Test/Combinatorics.cs rename to Tests/SuperLinq.Tests/Combinatorics.cs index 283509a52..7bd9fa8bf 100644 --- a/Tests/SuperLinq.Test/Combinatorics.cs +++ b/Tests/SuperLinq.Tests/Combinatorics.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; public static class Combinatorics { diff --git a/Tests/SuperLinq.Test/CompareCountTest.cs b/Tests/SuperLinq.Tests/CompareCountTest.cs similarity index 86% rename from Tests/SuperLinq.Test/CompareCountTest.cs rename to Tests/SuperLinq.Tests/CompareCountTest.cs index d190e7d82..0a3d452ad 100644 --- a/Tests/SuperLinq.Test/CompareCountTest.cs +++ b/Tests/SuperLinq.Tests/CompareCountTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class CompareCountTest { - public static IEnumerable CompareCountData { get; } = + public static IEnumerable<(IEnumerable xs, IEnumerable ys, int expected)> CompareCountData() => from e in new[] { new { Count1 = 0, Count2 = 0, Comparison = 0 }, @@ -14,19 +14,20 @@ from s in GetTestSequenceKinds( Enumerable.Range(1, e.Count1), Enumerable.Range(1, e.Count2), (xs, ys) => new { First = xs, Second = ys }) - select new object[] { s.First.Data, s.Second.Data, e.Comparison }; + select (s.First.Data, s.Second.Data, e.Comparison); - [Theory, MemberData(nameof(CompareCountData))] + [Test] + [MethodDataSource(nameof(CompareCountData))] public void CompareCount(IEnumerable xs, IEnumerable ys, int expected) { Assert.Equal(expected, xs.CompareCount(ys)); } - [Theory] - [InlineData(0, 0, 0, 1)] - [InlineData(0, 1, -1, 1)] - [InlineData(1, 0, 1, 1)] - [InlineData(1, 1, 0, 2)] + [Test] + [Arguments(0, 0, 0, 1)] + [Arguments(0, 1, -1, 1)] + [Arguments(1, 0, 1, 1)] + [Arguments(1, 1, 0, 2)] public void CompareCountWithCollectionAndSequence( int collectionCount, int sequenceCount, @@ -40,11 +41,11 @@ public void CompareCountWithCollectionAndSequence( Assert.Equal(expectedMoveNextCallCount, seq.MoveNextCallCount); } - [Theory] - [InlineData(0, 0, 0, 1)] - [InlineData(0, 1, -1, 1)] - [InlineData(1, 0, 1, 1)] - [InlineData(1, 1, 0, 2)] + [Test] + [Arguments(0, 0, 0, 1)] + [Arguments(0, 1, -1, 1)] + [Arguments(1, 0, 1, 1)] + [Arguments(1, 1, 0, 2)] public void CompareCountWithSequenceAndCollection( int sequenceCount, int collectionCount, @@ -58,11 +59,11 @@ public void CompareCountWithSequenceAndCollection( Assert.Equal(expectedMoveNextCallCount, seq.MoveNextCallCount); } - [Theory] - [InlineData(0, 0, 0, 1)] - [InlineData(0, 1, -1, 1)] - [InlineData(1, 0, 1, 1)] - [InlineData(1, 1, 0, 2)] + [Test] + [Arguments(0, 0, 0, 1)] + [Arguments(0, 1, -1, 1)] + [Arguments(1, 0, 1, 1)] + [Arguments(1, 1, 0, 2)] public void CompareCountWithSequenceAndSequence( int sequenceCount1, int sequenceCount2, @@ -77,7 +78,7 @@ public void CompareCountWithSequenceAndSequence( Assert.Equal(expectedMoveNextCallCount, seq2.MoveNextCallCount); } - [Fact] + [Test] public void CompareCountDisposesSequenceEnumerators() { using var seq1 = TestingSequence.Of(); @@ -86,7 +87,7 @@ public void CompareCountDisposesSequenceEnumerators() Assert.Equal(0, seq1.CompareCount(seq2)); } - [Fact] + [Test] public void CompareCountDisposesFirstEnumerator() { using var collection = new BreakingCollection([]); @@ -95,7 +96,7 @@ public void CompareCountDisposesFirstEnumerator() Assert.Equal(0, seq.CompareCount(collection)); } - [Fact] + [Test] public void CompareCountDisposesSecondEnumerator() { using var collection = new BreakingCollection([]); @@ -104,7 +105,7 @@ public void CompareCountDisposesSecondEnumerator() Assert.Equal(0, collection.CompareCount(seq)); } - [Fact] + [Test] public void CompareCountDoesNotIterateUnnecessaryElements() { using var seq1 = SeqExceptionAt(5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ConsumeTest.cs b/Tests/SuperLinq.Tests/ConsumeTest.cs similarity index 86% rename from Tests/SuperLinq.Test/ConsumeTest.cs rename to Tests/SuperLinq.Tests/ConsumeTest.cs index 47d263768..8a05b78e6 100644 --- a/Tests/SuperLinq.Test/ConsumeTest.cs +++ b/Tests/SuperLinq.Tests/ConsumeTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ConsumeTest { - [Fact] + [Test] public void ConsumeReallyConsumes() { var counter = 0; diff --git a/Tests/SuperLinq.Test/CopyToTest.cs b/Tests/SuperLinq.Tests/CopyToTest.cs similarity index 97% rename from Tests/SuperLinq.Test/CopyToTest.cs rename to Tests/SuperLinq.Tests/CopyToTest.cs index 9e84302d4..e1131fa28 100644 --- a/Tests/SuperLinq.Test/CopyToTest.cs +++ b/Tests/SuperLinq.Tests/CopyToTest.cs @@ -1,13 +1,13 @@ using System.Collections.ObjectModel; using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; #pragma warning disable IDE0034 public sealed class CopyToTest { - [Fact] + [Test] public void NullArgumentTest() { _ = Assert.Throws( @@ -33,7 +33,7 @@ public void NullArgumentTest() () => Seq().CopyTo(default(IList)!, 1)); } - [Fact] + [Test] public void ThrowsOnNegativeIndex() { _ = Assert.Throws( @@ -41,7 +41,7 @@ public void ThrowsOnNegativeIndex() () => Seq().CopyTo([], -1)); } - [Fact] + [Test] public void ThrowsOnTooMuchDataForArray() { _ = Assert.Throws( @@ -52,7 +52,7 @@ public void ThrowsOnTooMuchDataForArray() () => new List { 1 }.AsReadOnly().AsEnumerable().CopyTo(Array.Empty())); } - [Fact] + [Test] [SuppressMessage( "Style", "IDE0301:Simplify collection initialization", @@ -70,7 +70,7 @@ public void ThrowsOnTooMuchDataForIListArray() () => new List { 1 }.AsReadOnly().AsEnumerable().CopyTo((IList)Array.Empty())); } - [Fact] + [Test] public void ThrowsOnTooMuchDataForSpan() { _ = Assert.Throws( @@ -79,7 +79,7 @@ public void ThrowsOnTooMuchDataForSpan() () => new List { 1 }.AsEnumerable().CopyTo([])); } - [Fact] + [Test] public void CopiesDataToSpan() { Span span = stackalloc int[4]; @@ -98,7 +98,7 @@ public void CopiesDataToSpan() Assert.Equal(2, cnt); } - [Fact] + [Test] public void CopiesDataToArray() { var array = new int[4]; @@ -121,7 +121,7 @@ public void CopiesDataToArray() Assert.Equal(1, cnt); } - [Fact] + [Test] public void CopiesDataToList() { var list = new List(); @@ -145,7 +145,7 @@ public void CopiesDataToList() } } - [Fact] + [Test] public void CopiesDataToIList() { var list = new Collection(); diff --git a/Tests/SuperLinq.Test/CountBetweenTest.cs b/Tests/SuperLinq.Tests/CountBetweenTest.cs similarity index 51% rename from Tests/SuperLinq.Test/CountBetweenTest.cs rename to Tests/SuperLinq.Tests/CountBetweenTest.cs index 1a144e235..ac00b98f4 100644 --- a/Tests/SuperLinq.Test/CountBetweenTest.cs +++ b/Tests/SuperLinq.Tests/CountBetweenTest.cs @@ -1,59 +1,58 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class CountBetweenTest { - [Fact] + [Test] public void CountBetweenWithNegativeMin() { _ = Assert.Throws(() => new BreakingSequence().CountBetween(-1, 0)); } - [Fact] + [Test] public void CountBetweenWithNegativeMax() { _ = Assert.Throws(() => new BreakingSequence().CountBetween(0, -1)); } - [Fact] + [Test] public void CountBetweenWithMaxLesserThanMin() { _ = Assert.Throws(() => new BreakingSequence().CountBetween(1, 0)); } - public static IEnumerable GetSequences(IEnumerable seq) => - seq - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void CountBetweenWithMaxEqualsMin(IDisposableEnumerable seq) { using (seq) Assert.True(seq.CountBetween(1, 1)); } - public static IEnumerable GetTestData(int count, int min, int max, bool expecting) => - Enumerable.Range(1, count) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x, min, max, expecting }); - - [Theory] - [MemberData(nameof(GetTestData), 1, 2, 4, false)] - [MemberData(nameof(GetTestData), 2, 2, 4, true)] - [MemberData(nameof(GetTestData), 3, 2, 4, true)] - [MemberData(nameof(GetTestData), 4, 2, 4, true)] - [MemberData(nameof(GetTestData), 5, 2, 4, false)] - public void CountBetweenRangeTests(IDisposableEnumerable seq, int min, int max, bool expecting) + public static IEnumerable<(IDisposableEnumerable seq, bool expected)> GetTestData() => + Seq( + (1, false), + (2, true), + (3, true), + (4, true), + (5, false) + ) + .SelectMany(x => Enumerable.Range(1, x.Item1) + .GetBreakingCollectionSequences() + .Select(y => (y, x.Item2)) + ); + + [Test] + [MethodDataSource(nameof(GetTestData))] + public void CountBetweenRangeTests(IDisposableEnumerable seq, bool expected) { using (seq) - Assert.Equal(expecting, seq.CountBetween(min, max)); + Assert.Equal(expected, seq.CountBetween(2, 4)); } - [Fact] + [Test] public void CountBetweenDoesNotIterateUnnecessaryElements() { using var source = SeqExceptionAt(5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/CountByTest.cs b/Tests/SuperLinq.Tests/CountByTest.cs similarity index 96% rename from Tests/SuperLinq.Test/CountByTest.cs rename to Tests/SuperLinq.Tests/CountByTest.cs index 4c67cfc79..0f3887c2a 100644 --- a/Tests/SuperLinq.Test/CountByTest.cs +++ b/Tests/SuperLinq.Tests/CountByTest.cs @@ -1,9 +1,9 @@ -namespace Test; +namespace SuperLinq.Tests; [Obsolete("References `CountBy` which is obsolete in net9+")] public sealed class CountByTest { - [Fact] + [Test] public void CountBySimpleTest() { using var xs = TestingSequence.Of(1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 1, 2); @@ -19,7 +19,7 @@ public void CountBySimpleTest() CreatePair(6, 1)); } - [Fact] + [Test] public void CountByWithSecondOccurenceImmediatelyAfterFirst() { using var xs = "jaffer".AsTestingSequence(); @@ -34,7 +34,7 @@ public void CountByWithSecondOccurenceImmediatelyAfterFirst() CreatePair('r', 1)); } - [Fact] + [Test] public void CountByEvenOddTest() { using var xs = Enumerable.Range(1, 100) @@ -46,7 +46,7 @@ public void CountByEvenOddTest() CreatePair(0, 50)); } - [Fact] + [Test] public void CountByWithEqualityComparer() { using var xs = TestingSequence.Of("a", "B", "c", "A", "b", "A"); @@ -59,7 +59,7 @@ public void CountByWithEqualityComparer() CreatePair("c", 1)); } - [Fact] + [Test] public void CountByHasKeysOrderedLikeGroupBy() { var randomSequence = SuperEnumerable.Random(0, 100).Take(100).ToArray(); @@ -71,13 +71,13 @@ public void CountByHasKeysOrderedLikeGroupBy() countByKeys.AssertSequenceEqual(groupByKeys); } - [Fact] + [Test] public void CountByIsLazy() { _ = SuperEnumerable.CountBy(new BreakingSequence(), BreakingFunc.Of()); } - [Fact] + [Test] public void CountByWithSomeNullKeys() { using var xs = TestingSequence.Of("foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"); diff --git a/Tests/SuperLinq.Test/CountDownTest.cs b/Tests/SuperLinq.Tests/CountDownTest.cs similarity index 80% rename from Tests/SuperLinq.Test/CountDownTest.cs rename to Tests/SuperLinq.Tests/CountDownTest.cs index 025658859..8e76b0191 100644 --- a/Tests/SuperLinq.Test/CountDownTest.cs +++ b/Tests/SuperLinq.Tests/CountDownTest.cs @@ -1,38 +1,39 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class CountDownTest { - [Fact] + [Test] public void IsLazy() { _ = new BreakingSequence() .CountDown(42, BreakingFunc.Of()); } - [Theory] - [InlineData(0), InlineData(-1)] + [Test] + [Arguments(0), Arguments(-1)] public void ExceptionOnNegativeCount(int param) { _ = Assert.Throws("count", () => new BreakingSequence().CountDown(param)); } - public static IEnumerable GetTheoryData() + public static IEnumerable<(IDisposableEnumerable seq, int count, IEnumerable<(int, int?)> expected)> GetTestCases() { var xs = Enumerable.Range(0, 5).ToList(); for (var i = 1; i <= 7; i++) { var countdown = i < 5 - ? Enumerable.Repeat(null, 5 - i).Concat(Enumerable.Range(0, i).Select(x => (int?)x).Reverse()) - : Enumerable.Range(0, 5).Select(x => (int?)x).Reverse(); + ? Enumerable.Repeat(null, 5 - i).Concat(Enumerable.Range(0, i).Cast().Reverse()) + : Enumerable.Range(0, 5).Cast().Reverse(); foreach (var seq in xs.GetAllSequences()) - yield return new object[] { seq, i, xs.EquiZip(countdown) }; + yield return (seq, i, xs.EquiZip(countdown)); } } - [Theory, MemberData(nameof(GetTheoryData))] + [Test] + [MethodDataSource(nameof(GetTestCases))] public void WithSequence(IDisposableEnumerable seq, int count, IEnumerable<(int, int?)> expected) { using (seq) @@ -42,7 +43,7 @@ public void WithSequence(IDisposableEnumerable seq, int count, IEnumerable< } } - [Fact] + [Test] public void UsesCollectionCountAtIterationTime() { var stack = new Stack(Enumerable.Range(1, 3)); @@ -52,7 +53,7 @@ public void UsesCollectionCountAtIterationTime() result.AssertSequenceEqual(default(int?), null, 1, 0); } - [Fact] + [Test] public void CountDownCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -61,7 +62,7 @@ public void CountDownCollectionBehavior() result.AssertCollectionErrorChecking(10_000); } - [Fact] + [Test] public void CountDownListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/DeferTest.cs b/Tests/SuperLinq.Tests/DeferTest.cs similarity index 93% rename from Tests/SuperLinq.Test/DeferTest.cs rename to Tests/SuperLinq.Tests/DeferTest.cs index 5cd05d057..057ac7ed0 100644 --- a/Tests/SuperLinq.Test/DeferTest.cs +++ b/Tests/SuperLinq.Tests/DeferTest.cs @@ -1,17 +1,17 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT License. -namespace Test; +namespace SuperLinq.Tests; public sealed class DeferTest { - [Fact] + [Test] public void DeferIsLazy() { _ = SuperEnumerable.Defer(BreakingFunc.Of>()); } - [Fact] + [Test] public void DeferBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Test/DensePartialSortByTest.cs b/Tests/SuperLinq.Tests/DensePartialSortByTest.cs similarity index 94% rename from Tests/SuperLinq.Test/DensePartialSortByTest.cs rename to Tests/SuperLinq.Tests/DensePartialSortByTest.cs index d55512f80..c9e89beb0 100644 --- a/Tests/SuperLinq.Test/DensePartialSortByTest.cs +++ b/Tests/SuperLinq.Tests/DensePartialSortByTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class DensePartialSortByTests { - [Fact] + [Test] public void DensePartialSortByIsLazy() { _ = new BreakingSequence().DensePartialSortBy(1, BreakingFunc.Of()); } - [Fact] + [Test] public void DensePartialSortBy() { var ns = SuperEnumerable.RandomDouble().Take(10).ToArray(); @@ -24,9 +24,9 @@ public void DensePartialSortBy() ns.Take(3).SelectMany(x => new[] { x, x })); } - [Theory] - [InlineData(OrderByDirection.Ascending)] - [InlineData(OrderByDirection.Descending)] + [Test] + [Arguments(OrderByDirection.Ascending)] + [Arguments(OrderByDirection.Descending)] public void DensePartialSortWithOrder(OrderByDirection direction) { var ns = SuperEnumerable.RandomDouble() @@ -47,7 +47,7 @@ public void DensePartialSortWithOrder(OrderByDirection direction) ns.Take(3).SelectMany(x => new[] { x, x })); } - [Fact] + [Test] public void DensePartialSortWithComparer() { var alphabet = Enumerable.Range(0, 26) @@ -65,7 +65,7 @@ public void DensePartialSortWithComparer() .AssertSequenceEqual('A', 'A', 'C', 'C', 'E', 'E'); } - [Fact] + [Test] public void DensePartialSortByIsStable() { using var list = new[] diff --git a/Tests/SuperLinq.Test/DensePartialSortTest.cs b/Tests/SuperLinq.Tests/DensePartialSortTest.cs similarity index 93% rename from Tests/SuperLinq.Test/DensePartialSortTest.cs rename to Tests/SuperLinq.Tests/DensePartialSortTest.cs index 1713695a3..8db24859d 100644 --- a/Tests/SuperLinq.Test/DensePartialSortTest.cs +++ b/Tests/SuperLinq.Tests/DensePartialSortTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class DensePartialSortTests { - [Fact] + [Test] public void DensePartialSortIsLazy() { _ = new BreakingSequence().DensePartialSort(1); } - [Fact] + [Test] public void DensePartialSort() { using var xs = Enumerable.Range(1, 10) @@ -22,9 +22,9 @@ public void DensePartialSort() .AssertSequenceEqual(0, 1, 1, 2, 2); } - [Theory] - [InlineData(OrderByDirection.Ascending)] - [InlineData(OrderByDirection.Descending)] + [Test] + [Arguments(OrderByDirection.Ascending)] + [Arguments(OrderByDirection.Descending)] public void DensePartialSortWithOrder(OrderByDirection direction) { using var xs = Enumerable.Range(1, 10) @@ -40,7 +40,7 @@ public void DensePartialSortWithOrder(OrderByDirection direction) sorted.AssertSequenceEqual(0, 1, 1, 2, 2); } - [Fact] + [Test] public void DensePartialSortWithComparer() { var alphabet = Enumerable.Range(0, 26) @@ -57,7 +57,7 @@ public void DensePartialSortWithComparer() .AssertSequenceEqual('A', 'A', 'C', 'C', 'E', 'E'); } - [Fact] + [Test] public void DensePartialSortIsStable() { using var list = new[] diff --git a/Tests/SuperLinq.Test/DenseRankTest.cs b/Tests/SuperLinq.Tests/DenseRankTest.cs similarity index 83% rename from Tests/SuperLinq.Test/DenseRankTest.cs rename to Tests/SuperLinq.Tests/DenseRankTest.cs index c3185455b..011e1c6a8 100644 --- a/Tests/SuperLinq.Test/DenseRankTest.cs +++ b/Tests/SuperLinq.Tests/DenseRankTest.cs @@ -1,11 +1,11 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class DenseRankTests { /// /// Verify that DenseRank uses deferred execution /// - [Fact] + [Test] public void TestDenseRankIsLazy() { _ = new BreakingSequence().DenseRank(); @@ -15,24 +15,23 @@ public void TestDenseRankIsLazy() /// /// Verify that DenseRankBy uses deferred execution /// - [Fact] + [Test] public void TestDenseRankByIsLazy() { _ = new BreakingSequence().DenseRankBy(BreakingFunc.Of()); _ = new BreakingSequence().DenseRankBy(BreakingFunc.Of(), OrderByDirection.Ascending); } - public static IEnumerable GetSimpleSequences() => + public static IEnumerable> GetSimpleSequences() => Enumerable.Repeat(1, 10) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that calling DenseRank with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Theory] - [MemberData(nameof(GetSimpleSequences))] + [Test] + [MethodDataSource(nameof(GetSimpleSequences))] public void TestRankNullComparer(IDisposableEnumerable seq) { var expected = Enumerable.Repeat((1, 1), 10); @@ -52,8 +51,8 @@ public void TestRankNullComparer(IDisposableEnumerable seq) /// Verify that calling DenseRankBy with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Theory] - [MemberData(nameof(GetSimpleSequences))] + [Test] + [MethodDataSource(nameof(GetSimpleSequences))] public void TestRankByNullComparer(IDisposableEnumerable seq) { var expected = Enumerable.Repeat((1, 1), 10); @@ -69,19 +68,18 @@ public void TestRankByNullComparer(IDisposableEnumerable seq) } } - public static IEnumerable GetDescendingIntSequences() => + public static IEnumerable> GetDescendingIntSequences() => Enumerable.Range(456, 100) .Reverse() - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that calling DenseRank with null comparer on a source in reverse order /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Theory] - [MemberData(nameof(GetDescendingIntSequences))] + [Test] + [MethodDataSource(nameof(GetDescendingIntSequences))] public void TestRankDescendingSequence(IDisposableEnumerable seq) { var expected = @@ -101,18 +99,17 @@ public void TestRankDescendingSequence(IDisposableEnumerable seq) } } - public static IEnumerable GetAscendingIntSequences() => + public static IEnumerable> GetAscendingIntSequences() => Enumerable.Range(456, 100) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that calling DenseRank with null comparer on a source in ascending order /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Theory] - [MemberData(nameof(GetAscendingIntSequences))] + [Test] + [MethodDataSource(nameof(GetAscendingIntSequences))] public void TestRankAscendingSequence(IDisposableEnumerable seq) { var expected = @@ -137,8 +134,8 @@ public void TestRankAscendingSequence(IDisposableEnumerable seq) /// results in a sequence in descending order, using OrderByDirection.Descending /// with the default comparer for the given element. /// - [Theory] - [MemberData(nameof(GetAscendingIntSequences))] + [Test] + [MethodDataSource(nameof(GetAscendingIntSequences))] public void TestRankOrderByDescending(IDisposableEnumerable seq) { var expected = @@ -155,18 +152,17 @@ public void TestRankOrderByDescending(IDisposableEnumerable seq) } } - public static IEnumerable GetGroupedSequences() => + public static IEnumerable> GetGroupedSequences() => Enumerable.Range(0, 10) .Concat(Enumerable.Range(0, 10)) .Concat(Enumerable.Range(0, 10)) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that the rank of equivalent items in a sequence is the same. /// - [Theory] - [MemberData(nameof(GetGroupedSequences))] + [Test] + [MethodDataSource(nameof(GetGroupedSequences))] public void TestRankGroupedItems(IDisposableEnumerable seq) { var expected = @@ -192,7 +188,7 @@ public void TestRankGroupedItems(IDisposableEnumerable seq) } public sealed record Person(string Name, int Age, int ExpectedRank); - public static IEnumerable GetPersonSequences1() => + public static IEnumerable> GetPersonSequences1() => new[] { new Person(Name: "Bob", Age: 24, ExpectedRank: 4), @@ -204,10 +200,9 @@ public static IEnumerable GetPersonSequences1() => new Person(Name: "Jim", Age: 74, ExpectedRank: 8), new Person(Name: "Jes", Age: 11, ExpectedRank: 1), } - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); - public static IEnumerable GetPersonSequences2() => + public static IEnumerable> GetPersonSequences2() => new[] { new Person(Name: "Jes", Age: 30, ExpectedRank: 4), @@ -219,15 +214,14 @@ public static IEnumerable GetPersonSequences2() => new Person(Name: "Mel", Age: 28, ExpectedRank: 3), new Person(Name: "Jim", Age: 28, ExpectedRank: 3), } - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that we can rank items by an arbitrary key produced from the item. /// - [Theory] - [MemberData(nameof(GetPersonSequences1))] - [MemberData(nameof(GetPersonSequences2))] + [Test] + [MethodDataSource(nameof(GetPersonSequences1))] + [MethodDataSource(nameof(GetPersonSequences2))] public void TestRankByKeySelector(IDisposableEnumerable seq) { var expectedLength = 8; @@ -247,17 +241,16 @@ static bool HasExpectedRank(IEnumerable<(Person item, int rank)> result) => result.All(x => x.rank == x.item.ExpectedRank); } - public static IEnumerable GetDateTimeSequences() => + public static IEnumerable> GetDateTimeSequences() => Enumerable.Range(1, 10) .Select(x => new DateTime(2010, x, 20 - x)) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that Rank can use a custom comparer /// - [Theory] - [MemberData(nameof(GetDateTimeSequences))] + [Test] + [MethodDataSource(nameof(GetDateTimeSequences))] public void TestRankCustomComparer1(IDisposableEnumerable seq) { var expected = @@ -286,8 +279,8 @@ public void TestRankCustomComparer1(IDisposableEnumerable seq) /// /// Verify that RankBy can use a custom comparer with a key selector /// - [Theory] - [MemberData(nameof(GetDateTimeSequences))] + [Test] + [MethodDataSource(nameof(GetDateTimeSequences))] public void TestRankCustomComparer2(IDisposableEnumerable seq) { var expected = diff --git a/Tests/SuperLinq.Test/DistinctByTest.cs b/Tests/SuperLinq.Tests/DistinctByTest.cs similarity index 94% rename from Tests/SuperLinq.Test/DistinctByTest.cs rename to Tests/SuperLinq.Tests/DistinctByTest.cs index 789c675a3..7df565b69 100644 --- a/Tests/SuperLinq.Test/DistinctByTest.cs +++ b/Tests/SuperLinq.Tests/DistinctByTest.cs @@ -1,9 +1,9 @@ -namespace Test; +namespace SuperLinq.Tests; [Obsolete("References `DistinctBy` which is obsolete in net6+")] public sealed class DistinctByTest { - [Fact] + [Test] public void DistinctBy() { using var source = TestingSequence.Of("first", "second", "third", "fourth", "fifth"); @@ -11,13 +11,13 @@ public void DistinctBy() distinct.AssertSequenceEqual("first", "second"); } - [Fact] + [Test] public void DistinctByIsLazy() { _ = SuperEnumerable.DistinctBy(new BreakingSequence(), BreakingFunc.Of()); } - [Fact] + [Test] public void DistinctByWithComparer() { using var source = TestingSequence.Of("first", "FIRST", "second", "second", "third"); @@ -25,7 +25,7 @@ public void DistinctByWithComparer() distinct.AssertSequenceEqual("first", "second", "third"); } - [Fact] + [Test] public void DistinctByNullComparer() { using var source = TestingSequence.Of("first", "second", "third", "fourth", "fifth"); @@ -33,7 +33,7 @@ public void DistinctByNullComparer() distinct.AssertSequenceEqual("first", "second"); } - [Fact] + [Test] public void DistinctByIsLazyWithComparer() { _ = SuperEnumerable.DistinctBy(new BreakingSequence(), BreakingFunc.Of(), StringComparer.Ordinal); diff --git a/Tests/SuperLinq.Test/DistinctUntilChangedTest.cs b/Tests/SuperLinq.Tests/DistinctUntilChangedTest.cs similarity index 95% rename from Tests/SuperLinq.Test/DistinctUntilChangedTest.cs rename to Tests/SuperLinq.Tests/DistinctUntilChangedTest.cs index 07071d6a2..d12495b0a 100644 --- a/Tests/SuperLinq.Test/DistinctUntilChangedTest.cs +++ b/Tests/SuperLinq.Tests/DistinctUntilChangedTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class DistinctUntilChangedTest { - [Fact] + [Test] public void DistinctUntilChangedIsLazy() { _ = new BreakingSequence().DistinctUntilChanged(); } - [Fact] + [Test] public void DistinctUntilChangedEmptySequence() { using var source = TestingSequence.Of(); @@ -16,7 +16,7 @@ public void DistinctUntilChangedEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void DistinctUntilChanged() { using var source = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 0, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -24,7 +24,7 @@ public void DistinctUntilChanged() result.AssertSequenceEqual(2, 0, 5, 1, 0, 3, 0, 2, 3, 1, 4, 0, 2, 4, 3, 0); } - [Fact] + [Test] public void DistinctUntilChangedComparer() { using var source = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 0, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -33,13 +33,13 @@ public void DistinctUntilChangedComparer() result.AssertSequenceEqual(2, 0, 5, 1, 0, 2, 3, 1, 0, 2, 4, 3); } - [Fact] + [Test] public void DistinctUntilChangedSelectorIsLazy() { _ = new BreakingSequence().DistinctUntilChanged(BreakingFunc.Of()); } - [Fact] + [Test] public void DistinctUntilChangedSelectorEmptySequence() { using var source = TestingSequence.Of(); @@ -47,7 +47,7 @@ public void DistinctUntilChangedSelectorEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void DistinctUntilChangedSelector() { using var source = TestingSequence.Of( @@ -72,7 +72,7 @@ public void DistinctUntilChangedSelector() "ten"); } - [Fact] + [Test] public void DistinctUntilChangedSelectorComparer() { using var source = TestingSequence.Of( diff --git a/Tests/SuperLinq.Test/DoTest.cs b/Tests/SuperLinq.Tests/DoTest.cs similarity index 85% rename from Tests/SuperLinq.Test/DoTest.cs rename to Tests/SuperLinq.Tests/DoTest.cs index 41004c9d7..2e9ea48e7 100644 --- a/Tests/SuperLinq.Test/DoTest.cs +++ b/Tests/SuperLinq.Tests/DoTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class DoTest { - [Fact] + [Test] public void DoOverloadsAreLazy() { _ = new BreakingSequence().Do(BreakingAction.Of()); @@ -10,13 +10,12 @@ public void DoOverloadsAreLazy() _ = new BreakingSequence().Do(BreakingAction.Of(), BreakingAction.Of(), BreakingAction.Of()); } - public static IEnumerable GetSequences() => + public static IEnumerable> GetSequences() => Enumerable.Range(1, 10) - .GetTestingSequence() - .Select(x => new object[] { x }); + .GetTestingSequence(); - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void DoBehavior(IDisposableEnumerable seq) { using (seq) @@ -29,8 +28,8 @@ public void DoBehavior(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void DoCompletedBehavior(IDisposableEnumerable seq) { using (seq) @@ -43,8 +42,8 @@ public void DoCompletedBehavior(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void DoBehaviorNoError(IDisposableEnumerable seq) { using (seq) @@ -57,8 +56,8 @@ public void DoBehaviorNoError(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void DoCompletedBehaviorNoError(IDisposableEnumerable seq) { using (seq) @@ -71,7 +70,7 @@ public void DoCompletedBehaviorNoError(IDisposableEnumerable seq) } } - [Fact] + [Test] public void DoBehaviorError() { using var seq = SeqExceptionAt(11) @@ -88,7 +87,7 @@ public void DoBehaviorError() Assert.Equal(155, count); } - [Fact] + [Test] public void DoCompletedBehaviorError() { using var seq = SeqExceptionAt(11) diff --git a/Tests/SuperLinq.Test/DoWhileTest.cs b/Tests/SuperLinq.Tests/DoWhileTest.cs similarity index 92% rename from Tests/SuperLinq.Test/DoWhileTest.cs rename to Tests/SuperLinq.Tests/DoWhileTest.cs index 3491d351a..091347bb5 100644 --- a/Tests/SuperLinq.Test/DoWhileTest.cs +++ b/Tests/SuperLinq.Tests/DoWhileTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class DoWhileTest { - [Fact] + [Test] public void DoWhileIsLazy() { _ = new BreakingSequence().DoWhile(BreakingFunc.Of()); } - [Fact] + [Test] public void DoWhileBehavior() { using var ts = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Tests/DuplicatesTest.cs b/Tests/SuperLinq.Tests/DuplicatesTest.cs new file mode 100644 index 000000000..2e2b3d77c --- /dev/null +++ b/Tests/SuperLinq.Tests/DuplicatesTest.cs @@ -0,0 +1,40 @@ +namespace SuperLinq.Tests; + +public sealed class DuplicatesTest +{ + [Test] + public void DuplicatesIsLazy() + { + _ = new BreakingSequence().Duplicates(); + } + + [Test] + [Arguments(new int[] { 1, 2, 3 }, new int[] { })] + [Arguments(new int[] { 1, 2, 1, 3, 1, 2, 1 }, new int[] { 1, 2 })] + [Arguments(new int[] { 3, 3, 2, 2, 1, 1 }, new int[] { 3, 2, 1 })] + public void DuplicatesBehavior(IEnumerable source, IEnumerable expected) + { + using var ts = source.AsTestingSequence(); + + var result = ts.Duplicates(); + result.AssertSequenceEqual(expected); + } + + public static IEnumerable<(IEnumerable source, StringComparer comparer, IEnumerable expected)> GetStringParameters() => + [ + (["foo", "bar", "qux"], StringComparer.Ordinal, []), + (["foo", "FOO", "bar", "qux"], StringComparer.Ordinal, []), + (["foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, ["FOO"]), + (["Bar", "foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, ["FOO", "bar"]), + ]; + + [Test] + [MethodDataSource(nameof(GetStringParameters))] + public void DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, IEnumerable expected) + { + using var ts = source.AsTestingSequence(); + + var result = ts.Duplicates(comparer); + result.AssertSequenceEqual(expected); + } +} diff --git a/Tests/SuperLinq.Test/ElementAtTest.cs b/Tests/SuperLinq.Tests/ElementAtTest.cs similarity index 96% rename from Tests/SuperLinq.Test/ElementAtTest.cs rename to Tests/SuperLinq.Tests/ElementAtTest.cs index b4e67d770..0add41356 100644 --- a/Tests/SuperLinq.Test/ElementAtTest.cs +++ b/Tests/SuperLinq.Tests/ElementAtTest.cs @@ -3,13 +3,13 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class ElementAtTest { // simplified tests - already tested by fx, only need to prove that we don't step on fx toes - [Fact] + [Test] public void SameResultsRepeatCallsIntQuery() { var q = Enumerable.Repeat(from x in new[] { 9999, 0, 888, -1, 66, -777, 1, 2, -12345 } @@ -20,7 +20,7 @@ where x > int.MinValue Assert.Equal(q[2].ElementAt(^6), q[2].ElementAtOrDefault(^6)); } - [Fact] + [Test] public void SameResultsRepeatCallsStringQuery() { var q = Enumerable.Repeat(from x in new[] { "!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", "" } diff --git a/Tests/SuperLinq.Test/EndsWithTest.cs b/Tests/SuperLinq.Tests/EndsWithTest.cs similarity index 75% rename from Tests/SuperLinq.Test/EndsWithTest.cs rename to Tests/SuperLinq.Tests/EndsWithTest.cs index da9fd4236..5db476ed7 100644 --- a/Tests/SuperLinq.Test/EndsWithTest.cs +++ b/Tests/SuperLinq.Tests/EndsWithTest.cs @@ -1,13 +1,13 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class EndsWithTest { - [Theory] - [InlineData(new[] { 1, 2, 3 }, new[] { 2, 3 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 0, 1, 2, 3 }, false)] + [Test] + [Arguments(new[] { 1, 2, 3 }, new[] { 2, 3 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 0, 1, 2, 3 }, false)] public void EndsWithWithIntegers(IEnumerable first, IEnumerable second, bool expected) { using var f = first.AsTestingSequence(); @@ -15,10 +15,10 @@ public void EndsWithWithIntegers(IEnumerable first, IEnumerable second Assert.Equal(expected, f.EndsWith(s)); } - [Theory] - [InlineData(new[] { '1', '2', '3' }, new[] { '2', '3' }, true)] - [InlineData(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, true)] - [InlineData(new[] { '1', '2', '3' }, new[] { '0', '1', '2', '3' }, false)] + [Test] + [Arguments(new[] { '1', '2', '3' }, new[] { '2', '3' }, true)] + [Arguments(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, true)] + [Arguments(new[] { '1', '2', '3' }, new[] { '0', '1', '2', '3' }, false)] public void EndsWithWithChars(IEnumerable first, IEnumerable second, bool expected) { using var f = first.AsTestingSequence(); @@ -26,10 +26,10 @@ public void EndsWithWithChars(IEnumerable first, IEnumerable second, Assert.Equal(expected, f.EndsWith(s)); } - [Theory] - [InlineData("123", "23", true)] - [InlineData("123", "123", true)] - [InlineData("123", "0123", false)] + [Test] + [Arguments("123", "23", true)] + [Arguments("123", "123", true)] + [Arguments("123", "0123", false)] public void EndsWithWithStrings(string first, string second, bool expected) { using var f = first.AsTestingSequence(); @@ -37,7 +37,7 @@ public void EndsWithWithStrings(string first, string second, bool expected) Assert.Equal(expected, f.EndsWith(s)); } - [Fact] + [Test] public void EndsWithReturnsTrueIfBothEmpty() { using var f = Array.Empty().AsTestingSequence(); @@ -45,7 +45,7 @@ public void EndsWithReturnsTrueIfBothEmpty() Assert.True(f.EndsWith(s)); } - [Fact] + [Test] public void EndsWithReturnsFalseIfOnlyFirstIsEmpty() { using var f = TestingSequence.Of(); @@ -53,9 +53,9 @@ public void EndsWithReturnsFalseIfOnlyFirstIsEmpty() Assert.False(f.EndsWith(s)); } - [Theory] - [InlineData("", "", true)] - [InlineData("1", "", true)] + [Test] + [Arguments("", "", true)] + [Arguments("1", "", true)] public void EndsWithReturnsTrueIfSecondIsEmpty(string first, string second, bool expected) { using var f = first.AsTestingSequence(); @@ -63,7 +63,7 @@ public void EndsWithReturnsTrueIfSecondIsEmpty(string first, string second, bool Assert.Equal(expected, f.EndsWith(s)); } - [Fact] + [Test] public void EndsWithUsesSpecifiedEqualityComparerOrDefault() { var first = Seq(1, 2, 3); @@ -75,7 +75,7 @@ public void EndsWithUsesSpecifiedEqualityComparerOrDefault() Assert.True(first.EndsWith(second, EqualityComparer.Create(delegate { return true; }))); } - [Fact] + [Test] public void EndsWithUsesCollectionsCountToAvoidUnnecessaryIteration() { using var first = new BreakingCollection(1, 2); diff --git a/Tests/SuperLinq.Test/EqualityComparer.cs b/Tests/SuperLinq.Tests/EqualityComparer.cs similarity index 96% rename from Tests/SuperLinq.Test/EqualityComparer.cs rename to Tests/SuperLinq.Tests/EqualityComparer.cs index 9a1b3576e..9028289da 100644 --- a/Tests/SuperLinq.Test/EqualityComparer.cs +++ b/Tests/SuperLinq.Tests/EqualityComparer.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; internal static class EqualityComparer { diff --git a/Tests/SuperLinq.Test/EquiZipTest.cs b/Tests/SuperLinq.Tests/EquiZipTest.cs similarity index 78% rename from Tests/SuperLinq.Test/EquiZipTest.cs rename to Tests/SuperLinq.Tests/EquiZipTest.cs index 6ebc182a2..2791e9677 100644 --- a/Tests/SuperLinq.Test/EquiZipTest.cs +++ b/Tests/SuperLinq.Tests/EquiZipTest.cs @@ -1,6 +1,6 @@ using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; public sealed class EquiZipTest { @@ -17,7 +17,7 @@ public sealed class EquiZipTest "Eighth", ]; - [Fact] + [Test] public void EquiZipIsLazy() { var bs = new BreakingSequence(); @@ -26,7 +26,7 @@ public void EquiZipIsLazy() _ = bs.EquiZip(bs, bs, bs, BreakingFunc.Of()); } - [Fact] + [Test] public void MoveNextIsNotCalledUnnecessarily3() { using var s1 = TestingSequence.Of(1, 2); @@ -38,7 +38,7 @@ public void MoveNextIsNotCalledUnnecessarily3() s1.EquiZip(s2, s3).Consume()); } - [Fact] + [Test] public void MoveNextIsNotCalledUnnecessarily4() { using var s1 = TestingSequence.Of(1, 2); @@ -57,7 +57,7 @@ public void MoveNextIsNotCalledUnnecessarily4() } #region Two - [Fact] + [Test] public void TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -71,15 +71,15 @@ public void TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() "CA2000:Dispose objects before losing scope", Justification = "Will be properly disposed in method" )] - public static IEnumerable GetTwoParamEqualSequences() => + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2)> GetTwoParamEqualSequences() => [ - [Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(),], - [Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(),], - [Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(),], + (Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence()), + (Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence()), + (Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList()), ]; - [Theory] - [MemberData(nameof(GetTwoParamEqualSequences))] + [Test] + [MethodDataSource(nameof(GetTwoParamEqualSequences))] public void TwoParamsWorksProperly(IEnumerable seq1, IEnumerable seq2) { using (seq1 as IDisposableEnumerable) @@ -92,27 +92,29 @@ public void TwoParamsWorksProperly(IEnumerable seq1, IEnumerable seq2) } } - public static IEnumerable GetTwoParamInequalSequences() + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, string cardinal)> GetTwoParamInequalSequences() { - var parameters = new List(); + var parameters = new List<(IEnumerable seq1, IEnumerable seq2, string cardinal)>(); for (var i = 0; i < 2; i++) { var first = Enumerable.Range(1, 3 - (i == 0 ? 1 : 0)); var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [first.AsBreakingList(), second.AsBreakingList(), s_cardinals[i + 1],]); + (first.AsBreakingList(), second.AsBreakingList(), s_cardinals[i + 1]) + ); + parameters.Add( - [first.AsTestingSequence(), second.AsTestingSequence(), s_cardinals[i + 1],]); -#pragma warning restore CA2000 // Dispose objects before losing scope + (first.AsTestingSequence(), second.AsTestingSequence(), s_cardinals[i + 1]) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetTwoParamInequalSequences))] + [Test] + [MethodDataSource(nameof(GetTwoParamInequalSequences))] public void TwoParamsThrowsProperly(IEnumerable seq1, IEnumerable seq2, string cardinal) { using (seq1 as IDisposableEnumerable) @@ -125,7 +127,7 @@ public void TwoParamsThrowsProperly(IEnumerable seq1, IEnumerable seq2 } } - [Fact] + [Test] public void TwoParamsEqualListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -140,7 +142,7 @@ public void TwoParamsEqualListBehavior() #endif } - [Fact] + [Test] public void TwoParamsInequalListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -153,7 +155,7 @@ public void TwoParamsInequalListBehavior() #endregion #region Three - [Fact] + [Test] public void ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -168,32 +170,32 @@ public void ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() "CA2000:Dispose objects before losing scope", Justification = "Will be properly disposed in method" )] - public static IEnumerable GetThreeParamEqualSequences() => + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3)> GetThreeParamEqualSequences() => [ - [ + ( Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ - Enumerable.Range(1, 3).AsBreakingList(), + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), - ], + Enumerable.Range(1, 3).AsBreakingList() + ), ]; - [Theory] - [MemberData(nameof(GetThreeParamEqualSequences))] + [Test] + [MethodDataSource(nameof(GetThreeParamEqualSequences))] public void ThreeParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3) { using (seq1 as IDisposableEnumerable) @@ -207,38 +209,40 @@ public void ThreeParamsWorksProperly(IEnumerable seq1, IEnumerable seq } } - public static IEnumerable GetThreeParamInequalSequences() + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, string cardinal)> GetThreeParamInequalSequences() { - var parameters = new List(); + var parameters = new List<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, string cardinal)>(); for (var i = 0; i < 3; i++) { var first = Enumerable.Range(1, 3 - (i == 0 ? 1 : 0)); var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); var third = Enumerable.Range(1, 3 - (i == 2 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [ + ( first.AsBreakingList(), second.AsBreakingList(), third.AsBreakingList(), - s_cardinals[i + 1], - ]); + s_cardinals[i + 1] + ) + ); + parameters.Add( - [ + ( first.AsTestingSequence(), second.AsTestingSequence(), third.AsTestingSequence(), - s_cardinals[i + 1], - ]); -#pragma warning restore CA2000 // Dispose objects before losing scope + s_cardinals[i + 1] + ) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetThreeParamInequalSequences))] + [Test] + [MethodDataSource(nameof(GetThreeParamInequalSequences))] public void ThreeParamsThrowsProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, string cardinal) { using (seq1 as IDisposableEnumerable) @@ -252,7 +256,7 @@ public void ThreeParamsThrowsProperly(IEnumerable seq1, IEnumerable se } } - [Fact] + [Test] public void ThreeParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -268,7 +272,7 @@ public void ThreeParamsListBehavior() #endif } - [Fact] + [Test] public void ThreeParamsInequalListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -282,7 +286,7 @@ public void ThreeParamsInequalListBehavior() #endregion #region Four - [Fact] + [Test] public void FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -298,42 +302,47 @@ public void FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() "CA2000:Dispose objects before losing scope", Justification = "Will be properly disposed in method" )] - public static IEnumerable GetFourParamEqualSequences() => + public static IEnumerable<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4 + )> GetFourParamEqualSequences() => [ - [ + ( Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), - Enumerable.Range(1, 3).AsTestingSequence(), - ], - [ + Enumerable.Range(1, 3).AsTestingSequence() + ), + ( Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), - Enumerable.Range(1, 3).AsBreakingList(), - ], + Enumerable.Range(1, 3).AsBreakingList() + ), ]; - [Theory] - [MemberData(nameof(GetFourParamEqualSequences))] + [Test] + [MethodDataSource(nameof(GetFourParamEqualSequences))] public void FourParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, IEnumerable seq4) { using (seq1 as IDisposableEnumerable) @@ -348,9 +357,21 @@ public void FourParamsWorksProperly(IEnumerable seq1, IEnumerable seq2 } } - public static IEnumerable GetFourParamInequalSequences() + public static IEnumerable<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + string cardinal + )> GetFourParamInequalSequences() { - var parameters = new List(); + var parameters = new List<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + string cardinal + )>(); for (var i = 0; i < 4; i++) { @@ -358,31 +379,33 @@ public static IEnumerable GetFourParamInequalSequences() var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); var third = Enumerable.Range(1, 3 - (i == 2 ? 1 : 0)); var fourth = Enumerable.Range(1, 3 - (i == 3 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [ + ( first.AsBreakingList(), second.AsBreakingList(), third.AsBreakingList(), fourth.AsBreakingList(), - s_cardinals[i + 1], - ]); + s_cardinals[i + 1] + ) + ); + parameters.Add( - [ + ( first.AsTestingSequence(), second.AsTestingSequence(), third.AsTestingSequence(), fourth.AsTestingSequence(), - s_cardinals[i + 1], - ]); -#pragma warning restore CA2000 // Dispose objects before losing scope + s_cardinals[i + 1] + ) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetFourParamInequalSequences))] + [Test] + [MethodDataSource(nameof(GetFourParamInequalSequences))] public void FourParamsThrowsProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, IEnumerable seq4, string cardinal) { using (seq1 as IDisposableEnumerable) @@ -397,7 +420,7 @@ public void FourParamsThrowsProperly(IEnumerable seq1, IEnumerable seq } } - [Fact] + [Test] public void FourParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -414,7 +437,7 @@ public void FourParamsListBehavior() #endif } - [Fact] + [Test] public void FourParamsInequalListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/EvaluateTest.cs b/Tests/SuperLinq.Tests/EvaluateTest.cs similarity index 93% rename from Tests/SuperLinq.Test/EvaluateTest.cs rename to Tests/SuperLinq.Tests/EvaluateTest.cs index d89bad291..5bd7db47b 100644 --- a/Tests/SuperLinq.Test/EvaluateTest.cs +++ b/Tests/SuperLinq.Tests/EvaluateTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class EvaluateTest { - [Fact] + [Test] public void TestEvaluateIsLazy() { _ = new BreakingSequence>().Evaluate(); } - [Fact] + [Test] public void TestEvaluateInvokesMethods() { var factories = new Func[] @@ -23,7 +23,7 @@ public void TestEvaluateInvokesMethods() results.AssertSequenceEqual(-2, 4, int.MaxValue, int.MinValue); } - [Fact] + [Test] public void TestEvaluateInvokesMethodsMultipleTimes() { var evals = 0; diff --git a/Tests/SuperLinq.Test/ExactlyTest.cs b/Tests/SuperLinq.Tests/ExactlyTest.cs similarity index 67% rename from Tests/SuperLinq.Test/ExactlyTest.cs rename to Tests/SuperLinq.Tests/ExactlyTest.cs index f20d93ce9..14602530b 100644 --- a/Tests/SuperLinq.Test/ExactlyTest.cs +++ b/Tests/SuperLinq.Tests/ExactlyTest.cs @@ -1,84 +1,79 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ExactlyTest { - [Fact] + [Test] public void ExactlyWithNegativeCount() { _ = Assert.Throws(() => new BreakingSequence().Exactly(-1)); } - public static IEnumerable GetSequences(IEnumerable seq) => - seq - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetEmptySequences))] public void ExactlyWithEmptySequenceHasExactlyZeroElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.Exactly(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetEmptySequences))] public void ExactlyWithEmptySequenceHasExactlyOneElement(IDisposableEnumerable seq) { using (seq) Assert.False(seq.Exactly(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void ExactlyWithSingleElementHasExactlyZeroElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.Exactly(0)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void ExactlyWithSingleElementHasExactlyOneElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.Exactly(1)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetSingleElementSequences))] public void ExactlyWithSingleElementHasExactlyTwoElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.Exactly(2)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void ExactlyWithThreeElementsHasExactlyTwoElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.Exactly(2)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void ExactlyWithThreeElementsHasExactlyThreeElements(IDisposableEnumerable seq) { using (seq) Assert.True(seq.Exactly(3)); } - [Theory] - [MemberData(nameof(GetSequences), new int[] { 1, 2, 3 })] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(GetThreeElementSequences))] public void ExactlyWithThreeElementsHasExactlyFourElements(IDisposableEnumerable seq) { using (seq) Assert.False(seq.Exactly(4)); } - [Fact] + [Test] public void ExactlyDoesNotIterateUnnecessaryElements() { using var source = SeqExceptionAt(4).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ExceptByTest.cs b/Tests/SuperLinq.Tests/ExceptByTest.cs similarity index 95% rename from Tests/SuperLinq.Test/ExceptByTest.cs rename to Tests/SuperLinq.Tests/ExceptByTest.cs index 84a25d000..e291ba3c5 100644 --- a/Tests/SuperLinq.Test/ExceptByTest.cs +++ b/Tests/SuperLinq.Tests/ExceptByTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ExceptByTest { - [Fact] + [Test] public void SimpleExceptBy() { using var first = TestingSequence.Of("aaa", "bb", "c", "dddd"); @@ -11,14 +11,14 @@ public void SimpleExceptBy() result.AssertSequenceEqual("aaa", "dddd"); } - [Fact] + [Test] public void ExceptByIsLazy() { var bs = new BreakingSequence(); _ = bs.ExceptBy(bs, BreakingFunc.Of()); } - [Fact] + [Test] public void ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() { using var first = TestingSequence.Of("aaa", "bb", "c", "a", "b", "c", "dddd"); @@ -27,7 +27,7 @@ public void ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() result.AssertSequenceEqual("aaa", "c", "dddd"); } - [Fact] + [Test] public void ExceptByWithComparer() { using var first = TestingSequence.Of("first", "second", "third", "fourth"); @@ -36,7 +36,7 @@ public void ExceptByWithComparer() result.AssertSequenceEqual("second", "fourth"); } - [Fact] + [Test] public void ExceptByNullComparer() { using var first = TestingSequence.Of("aaa", "bb", "c", "dddd"); @@ -45,7 +45,7 @@ public void ExceptByNullComparer() result.AssertSequenceEqual("aaa", "dddd"); } - [Fact] + [Test] public void ExceptByIsLazyWithComparer() { var bs = new BreakingSequence(); diff --git a/Tests/SuperLinq.Test/ExcludeTest.cs b/Tests/SuperLinq.Tests/ExcludeTest.cs similarity index 67% rename from Tests/SuperLinq.Test/ExcludeTest.cs rename to Tests/SuperLinq.Tests/ExcludeTest.cs index 1340e55ef..e2cb2dc15 100644 --- a/Tests/SuperLinq.Test/ExcludeTest.cs +++ b/Tests/SuperLinq.Tests/ExcludeTest.cs @@ -1,33 +1,33 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Exclude operator /// public sealed class ExcludeTests { - [Fact] + [Test] public void TestExcludeIsLazy() { _ = new BreakingSequence().Exclude(0, 10); } - [Fact] + [Test] public void TestExcludeNegativeStartIndexException() { _ = Assert.Throws(() => new BreakingSequence().Exclude(-10, 10)); } - [Fact] + [Test] public void TestExcludeNegativeCountException() { _ = Assert.Throws(() => new BreakingSequence().Exclude(0, -5)); } - [Fact] + [Test] public void TestExcludeWithCountEqualsZero() { using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -36,13 +36,12 @@ public void TestExcludeWithCountEqualsZero() result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Enumerable.Range(1, 100) - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestExcludeSequenceHead(IDisposableEnumerable seq) { using (seq) @@ -52,8 +51,8 @@ public void TestExcludeSequenceHead(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestExcludeSequenceTail(IDisposableEnumerable seq) { using (seq) @@ -63,8 +62,8 @@ public void TestExcludeSequenceTail(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestExcludeSequenceMiddle(IDisposableEnumerable seq) { using (seq) @@ -76,8 +75,8 @@ public void TestExcludeSequenceMiddle(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestExcludeEntireSequence(IDisposableEnumerable seq) { using (seq) @@ -87,8 +86,8 @@ public void TestExcludeEntireSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestExcludeCountGreaterThanSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -98,8 +97,8 @@ public void TestExcludeCountGreaterThanSequenceLength(IDisposableEnumerable } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestExcludeStartIndexGreaterThanSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -110,7 +109,7 @@ public void TestExcludeStartIndexGreaterThanSequenceLength(IDisposableEnumerable } } - [Fact] + [Test] public void ExcludeListBehaviorMid() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -126,7 +125,7 @@ public void ExcludeListBehaviorMid() Assert.Equal(9_950, result.ElementAt(8_950)); } - [Fact] + [Test] public void ExcludeListBehaviorEnd() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -139,7 +138,7 @@ public void ExcludeListBehaviorEnd() Assert.Equal(9_450, result.ElementAt(^50)); } - [Fact] + [Test] public void ExcludeListBehaviorAfter() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -152,7 +151,7 @@ public void ExcludeListBehaviorAfter() Assert.Equal(9_950, result.ElementAt(^50)); } - [Fact] + [Test] public void ExcludeListBehaviorEntire() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -165,7 +164,7 @@ public void ExcludeListBehaviorEntire() () => result.ElementAt(0)); } - [Fact] + [Test] public void ExcludeCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -174,36 +173,35 @@ public void ExcludeCollectionBehavior() result.AssertCollectionErrorChecking(9_000); } - public static IEnumerable GetExcludeRangeCases() => + public static IEnumerable<(Range range, bool shouldThrow, bool __, int[] expected)> GetExcludeRangeCases() => [ - [3..7, false, false, new int[] { 0, 1, 2, 7, 8, 9 }], - [3..3, false, false, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [3..2, true, true, Array.Empty()], - [3..15, false, false, new int[] { 0, 1, 2 }], - - [3..^3, false, false, new int[] { 0, 1, 2, 7, 8, 9 }], - [6..^3, false, false, new int[] { 0, 1, 2, 3, 4, 5, 7, 8, 9 }], - [7..^3, false, false, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [8..^3, false, true, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [15..^3, false, true, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [3..^15, false, true, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - - [^7..2, false, true, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [^7..3, false, false, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [^7..4, false, false, new int[] { 0, 1, 2, 4, 5, 6, 7, 8, 9 }], - [^7..7, false, false, new int[] { 0, 1, 2, 7, 8, 9 }], - [^7..15, false, true, new int[] { 0, 1, 2 }], - [^15..7, false, true, new int[] { 7, 8, 9 }], - - [^2..^3, true, true, Array.Empty()], - [^3..^3, false, false, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }], - [^7..^3, false, false, new int[] { 0, 1, 2, 7, 8, 9 }], - [^15..^3, false, true, new int[] { 7, 8, 9 }], + (3..7, false, false, [0, 1, 2, 7, 8, 9]), + (3..3, false, false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (3..2, true, true, []), + (3..15, false, false, [0, 1, 2]), + + (3..^3, false, false, [0, 1, 2, 7, 8, 9]), + (6..^3, false, false, [0, 1, 2, 3, 4, 5, 7, 8, 9]), + (7..^3, false, false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (8..^3, false, true, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (15..^3, false, true, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (3..^15, false, true, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + + (^7..2, false, true, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (^7..3, false, false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (^7..4, false, false, [0, 1, 2, 4, 5, 6, 7, 8, 9]), + (^7..7, false, false, [0, 1, 2, 7, 8, 9]), + (^7..15, false, true, [0, 1, 2]), + (^15..7, false, true, [7, 8, 9]), + + (^2..^3, true, true, []), + (^3..^3, false, false, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + (^7..^3, false, false, [0, 1, 2, 7, 8, 9]), + (^15..^3, false, true, [7, 8, 9]), ]; - [Theory] - [MemberData(nameof(GetExcludeRangeCases))] - [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "xUnit1026:Theory methods should use all of their parameters")] + [Test] + [MethodDataSource(nameof(GetExcludeRangeCases))] public void ExcludeRangeBehavior(Range range, bool shouldThrow, bool __, int[] expected) { using var ts = Enumerable.Range(0, 10) @@ -221,9 +219,8 @@ public void ExcludeRangeBehavior(Range range, bool shouldThrow, bool __, int[] e result.AssertSequenceEqual(expected); } - [Theory] - [MemberData(nameof(GetExcludeRangeCases))] - [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "xUnit1026:Theory methods should use all of their parameters")] + [Test] + [MethodDataSource(nameof(GetExcludeRangeCases))] public void ExcludeRangeCollectionBehavior(Range range, bool __, bool shouldThrow, int[] expected) { using var ts = Enumerable.Range(0, 10) diff --git a/Tests/SuperLinq.Test/FallbackIfEmptyTest.cs b/Tests/SuperLinq.Tests/FallbackIfEmptyTest.cs similarity index 94% rename from Tests/SuperLinq.Test/FallbackIfEmptyTest.cs rename to Tests/SuperLinq.Tests/FallbackIfEmptyTest.cs index 3e2c760ac..896c14320 100644 --- a/Tests/SuperLinq.Test/FallbackIfEmptyTest.cs +++ b/Tests/SuperLinq.Tests/FallbackIfEmptyTest.cs @@ -1,36 +1,36 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class FallbackIfEmptyTest { - [Fact] + [Test] public void FallbackIfEmptyWithEmptySequence() { using var source = Seq().AsTestingSequence(); source.FallbackIfEmpty(12).AssertSequenceEqual(12); } - [Fact] + [Test] public void FallbackIfEmptyWithCollectionSequence() { using var source = Seq().AsTestingCollection(); source.FallbackIfEmpty(12).AssertSequenceEqual(12); } - [Fact] + [Test] public void FallbackIfEmptyWithNotEmptySequence() { using var source = Seq(1).AsTestingSequence(); source.FallbackIfEmpty(new BreakingSequence()).AssertSequenceEqual(1); } - [Fact] + [Test] public void FallbackIfEmptyWithNotEmptyCollectionSequence() { using var source = Seq(1).AsTestingCollection(); source.FallbackIfEmpty(new BreakingSequence()).AssertSequenceEqual(1); } - [Fact] + [Test] public void AssertFallbackIfEmptyCollectionBehaviorOnEmptyCollection() { using var source = Seq().AsBreakingCollection(); @@ -40,7 +40,7 @@ public void AssertFallbackIfEmptyCollectionBehaviorOnEmptyCollection() result.AssertCollectionErrorChecking(10_000); } - [Fact] + [Test] public void AssertFallbackIfEmptyCollectionBehaviorOnNonEmptyCollection() { using var source = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -50,7 +50,7 @@ public void AssertFallbackIfEmptyCollectionBehaviorOnNonEmptyCollection() result.AssertCollectionErrorChecking(10_000); } - [Fact] + [Test] public void FallbackIfEmptyUsesCollectionCountAtIterationTime() { var stack = new Stack(); diff --git a/Tests/SuperLinq.Test/FillBackwardTest.cs b/Tests/SuperLinq.Tests/FillBackwardTest.cs similarity index 73% rename from Tests/SuperLinq.Test/FillBackwardTest.cs rename to Tests/SuperLinq.Tests/FillBackwardTest.cs index 169b1c29a..48c5a210d 100644 --- a/Tests/SuperLinq.Test/FillBackwardTest.cs +++ b/Tests/SuperLinq.Tests/FillBackwardTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class FillBackwardTest { - [Fact] + [Test] public void FillBackwardIsLazy() { _ = new BreakingSequence().FillBackward(); @@ -10,13 +10,12 @@ public void FillBackwardIsLazy() _ = new BreakingSequence().FillBackward(BreakingFunc.Of(), BreakingFunc.Of()); } - public static IEnumerable GetIntNullSequences() => + public static IEnumerable> GetIntNullSequences() => Seq(null, null, 1, 2, null, null, null, 3, 4, null, null) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); + .GetBreakingCollectionSequences(); - [Theory] - [MemberData(nameof(GetIntNullSequences))] + [Test] + [MethodDataSource(nameof(GetIntNullSequences))] public void FillBackwardBlank(IDisposableEnumerable seq) { using (seq) @@ -27,8 +26,8 @@ public void FillBackwardBlank(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntNullSequences))] + [Test] + [MethodDataSource(nameof(GetIntNullSequences))] public void FillBackward(IDisposableEnumerable seq) { using (seq) @@ -39,13 +38,12 @@ public void FillBackward(IDisposableEnumerable seq) } } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Enumerable.Range(1, 13) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); + .GetBreakingCollectionSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void FillBackwardWithFillSelector(IDisposableEnumerable seq) { using (seq) @@ -56,7 +54,7 @@ public void FillBackwardWithFillSelector(IDisposableEnumerable seq) } } - [Fact] + [Test] public void FillBackwardCollectionCount() { using var sequence = Enumerable.Range(1, 10_000) diff --git a/Tests/SuperLinq.Test/FillForwardTest.cs b/Tests/SuperLinq.Tests/FillForwardTest.cs similarity index 87% rename from Tests/SuperLinq.Test/FillForwardTest.cs rename to Tests/SuperLinq.Tests/FillForwardTest.cs index a5b1d4cff..d00b84277 100644 --- a/Tests/SuperLinq.Test/FillForwardTest.cs +++ b/Tests/SuperLinq.Tests/FillForwardTest.cs @@ -1,10 +1,10 @@ using System.Globalization; -namespace Test; +namespace SuperLinq.Tests; public sealed class FillForwardTest { - [Fact] + [Test] public void FillForwardIsLazy() { _ = new BreakingSequence().FillForward(); @@ -12,13 +12,12 @@ public void FillForwardIsLazy() _ = new BreakingSequence().FillForward(BreakingFunc.Of(), BreakingFunc.Of()); } - public static IEnumerable GetIntNullSequences() => + public static IEnumerable> GetIntNullSequences() => Seq(null, null, 1, 2, null, null, null, 3, 4, null, null) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); + .GetBreakingCollectionSequences(); - [Theory] - [MemberData(nameof(GetIntNullSequences))] + [Test] + [MethodDataSource(nameof(GetIntNullSequences))] public void FillForwardBlank(IDisposableEnumerable seq) { using (seq) @@ -29,8 +28,8 @@ public void FillForwardBlank(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntNullSequences))] + [Test] + [MethodDataSource(nameof(GetIntNullSequences))] public void FillForward(IDisposableEnumerable seq) { using (seq) @@ -41,13 +40,12 @@ public void FillForward(IDisposableEnumerable seq) } } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Enumerable.Range(1, 13) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); + .GetBreakingCollectionSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void FillForwardWithFillSelector(IDisposableEnumerable seq) { using (seq) @@ -58,7 +56,7 @@ public void FillForwardWithFillSelector(IDisposableEnumerable seq) } } - [Fact] + [Test] public void FillForwardExample() { const string Table = @" @@ -101,7 +99,7 @@ select line.Trim() into line new { Continent = "Africa", Country = "Kenya", City = "Nairobi", Value = 901 }); } - [Fact] + [Test] public void FillForwardCollectionCount() { using var sequence = Enumerable.Range(1, 10_000) diff --git a/Tests/SuperLinq.Test/FinallyTest.cs b/Tests/SuperLinq.Tests/FinallyTest.cs similarity index 95% rename from Tests/SuperLinq.Test/FinallyTest.cs rename to Tests/SuperLinq.Tests/FinallyTest.cs index bce8491ed..a8e2c7439 100644 --- a/Tests/SuperLinq.Test/FinallyTest.cs +++ b/Tests/SuperLinq.Tests/FinallyTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class FinallyTest { - [Fact] + [Test] public void FinallyIsLazy() { _ = new BreakingSequence().Finally(BreakingAction.Of()); } - [Fact] + [Test] public void FinallyExecutesOnCompletion() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -21,7 +21,7 @@ public void FinallyExecutesOnCompletion() Assert.True(ran); } - [Fact] + [Test] public void FinallyExecutesOnException() { using var seq = SeqExceptionAt(4).AsTestingSequence(); @@ -39,7 +39,7 @@ public void FinallyExecutesOnException() Assert.True(ran); } - [Fact] + [Test] public void FinallyExecutesOnTake() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -54,7 +54,7 @@ public void FinallyExecutesOnTake() Assert.True(ran); } - [Fact] + [Test] public void FinallyExecutesOnEarlyDisposal() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/FindIndexTest.cs b/Tests/SuperLinq.Tests/FindIndexTest.cs similarity index 95% rename from Tests/SuperLinq.Test/FindIndexTest.cs rename to Tests/SuperLinq.Tests/FindIndexTest.cs index 355bbd7d8..b0ef673ec 100644 --- a/Tests/SuperLinq.Test/FindIndexTest.cs +++ b/Tests/SuperLinq.Tests/FindIndexTest.cs @@ -1,24 +1,24 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class FindIndexTest { - [Fact] + [Test] public void FindIndexWithNegativeCount() { _ = Assert.Throws(() => new BreakingSequence().FindIndex(BreakingFunc.Of(), 1, -1)); } - [Fact] + [Test] public void FindIndexWorksWithEmptySequence() { using var sequence = Array.Empty().AsTestingSequence(); Assert.Equal(-1, sequence.FindIndex(BreakingFunc.Of())); } - [Fact] + [Test] public void FindIndexFromStart() { using var sequence = Enumerable.Range(100, 5) @@ -28,7 +28,7 @@ public void FindIndexFromStart() sequence.FindIndex(i => i == 102)); } - [Fact] + [Test] public void FindIndexFromStartCount() { using var sequence = Enumerable.Range(100, 5) @@ -38,7 +38,7 @@ public void FindIndexFromStartCount() sequence.FindIndex(i => i == 102, 0, 3)); } - [Fact] + [Test] public void FindIndexFromStartIndex() { using var sequence = Enumerable.Range(100, 5) @@ -49,7 +49,7 @@ public void FindIndexFromStartIndex() sequence.FindIndex(i => i == 102, 5)); } - [Fact] + [Test] public void FindIndexFromEndIndex() { using var sequence = Enumerable.Range(100, 5) @@ -60,7 +60,7 @@ public void FindIndexFromEndIndex() sequence.FindIndex(i => i == 102, ^5)); } - [Fact] + [Test] public void FindIndexUsesCollectionLengthCorrectly() { var array = new int[20]; @@ -70,7 +70,7 @@ public void FindIndexUsesCollectionLengthCorrectly() array.FindIndex(i => i == 3, ^5)); } - [Fact] + [Test] public void FindIndexMissingValueFromStart() { using var sequence = Enumerable.Range(100, 5) @@ -80,7 +80,7 @@ public void FindIndexMissingValueFromStart() sequence.FindIndex(i => i == 95)); } - [Fact] + [Test] public void FindIndexMissingValueFromEnd() { using var sequence = Enumerable.Range(100, 5) @@ -90,7 +90,7 @@ public void FindIndexMissingValueFromEnd() sequence.FindIndex(i => i == 95, ^5)); } - [Fact] + [Test] public void FindIndexMissingValueFromStartCount() { using var sequence = Enumerable.Range(100, 5) @@ -100,7 +100,7 @@ public void FindIndexMissingValueFromStartCount() sequence.FindIndex(i => i == 104, 0, 4)); } - [Fact] + [Test] public void FindIndexMissingValueFromEndCount() { using var sequence = Enumerable.Range(100, 5) @@ -110,7 +110,7 @@ public void FindIndexMissingValueFromEndCount() sequence.FindIndex(i => i == 104, ^5, 4)); } - [Fact] + [Test] public void FindIndexDoesNotIterateUnnecessaryElements() { using var source = SuperEnumerable @@ -128,7 +128,7 @@ public void FindIndexDoesNotIterateUnnecessaryElements() Assert.Equal(4, source.FindIndex(i => i == "davi")); } - [Fact] + [Test] public void FindIndexDoesNotIterateUnnecessaryElementsCount() { using var source = SuperEnumerable diff --git a/Tests/SuperLinq.Test/FindLastIndexTest.cs b/Tests/SuperLinq.Tests/FindLastIndexTest.cs similarity index 95% rename from Tests/SuperLinq.Test/FindLastIndexTest.cs rename to Tests/SuperLinq.Tests/FindLastIndexTest.cs index 9666e2f7f..7cb85aa74 100644 --- a/Tests/SuperLinq.Test/FindLastIndexTest.cs +++ b/Tests/SuperLinq.Tests/FindLastIndexTest.cs @@ -1,24 +1,24 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class FindLastIndexTest { - [Fact] + [Test] public void FindLastIndexWithNegativeCount() { _ = Assert.Throws(() => new BreakingSequence().FindLastIndex(i => i == 1, 1, -1)); } - [Fact] + [Test] public void FindLastIndexWorksWithEmptySequence() { using var sequence = Array.Empty().AsTestingSequence(); Assert.Equal(-1, sequence.FindLastIndex(i => i == 5)); } - [Fact] + [Test] public void FindLastIndexFromStart() { using var sequence = Enumerable.Range(100, 5) @@ -29,7 +29,7 @@ public void FindLastIndexFromStart() sequence.FindLastIndex(i => i == 102)); } - [Fact] + [Test] public void FindLastIndexFromStartCount() { using var sequence = Enumerable.Range(100, 5) @@ -40,7 +40,7 @@ public void FindLastIndexFromStartCount() sequence.FindLastIndex(i => i == 102, int.MaxValue, 8)); } - [Fact] + [Test] public void FindLastIndexFromStartIndex() { using var sequence = Enumerable.Range(100, 5) @@ -51,7 +51,7 @@ public void FindLastIndexFromStartIndex() sequence.FindLastIndex(i => i == 102, 8)); } - [Fact] + [Test] public void FindLastIndexFromEndIndex() { using var sequence = Enumerable.Range(100, 5) @@ -62,7 +62,7 @@ public void FindLastIndexFromEndIndex() sequence.FindLastIndex(i => i == 102, ^3)); } - [Fact] + [Test] public void FindLastIndexUsesCollectionLengthCorrectly() { var array = new int[20]; @@ -73,7 +73,7 @@ public void FindLastIndexUsesCollectionLengthCorrectly() array.FindLastIndex(i => i == 3, ^6)); } - [Fact] + [Test] public void FindLastIndexMissingValueFromStart() { using var sequence = Enumerable.Range(100, 5) @@ -83,7 +83,7 @@ public void FindLastIndexMissingValueFromStart() sequence.FindLastIndex(i => i == 95)); } - [Fact] + [Test] public void FindLastIndexMissingValueFromEnd() { using var sequence = Enumerable.Range(100, 5) @@ -93,7 +93,7 @@ public void FindLastIndexMissingValueFromEnd() sequence.FindLastIndex(i => i == 95, ^5)); } - [Fact] + [Test] public void FindLastIndexMissingValueFromStartCount() { using var sequence = Enumerable.Range(100, 5) @@ -103,7 +103,7 @@ public void FindLastIndexMissingValueFromStartCount() sequence.FindLastIndex(i => i == 100, int.MaxValue, 4)); } - [Fact] + [Test] public void FindLastIndexMissingValueFromEndCount() { using var sequence = Enumerable.Range(100, 5) diff --git a/Tests/SuperLinq.Test/FlattenTest.cs b/Tests/SuperLinq.Tests/FlattenTest.cs similarity index 97% rename from Tests/SuperLinq.Test/FlattenTest.cs rename to Tests/SuperLinq.Tests/FlattenTest.cs index 5ce192522..8613cf772 100644 --- a/Tests/SuperLinq.Test/FlattenTest.cs +++ b/Tests/SuperLinq.Tests/FlattenTest.cs @@ -1,12 +1,12 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; public sealed class FlattenTest { // Flatten(this IEnumerable source) - [Fact] + [Test] public void Flatten() { using var l1 = TestingSequence.Of(4, "foo"); @@ -32,7 +32,7 @@ public void Flatten() 10); } - [Fact] + [Test] public void FlattenCast() { using var source = new object[] @@ -61,13 +61,13 @@ public void FlattenCast() .AssertSequenceEqual(Enumerable.Range(1, 20)); } - [Fact] + [Test] public void FlattenIsLazy() { _ = new BreakingSequence().Flatten(); } - [Fact] + [Test] public void FlattenPredicate() { using var source = new object[] @@ -109,7 +109,7 @@ public void FlattenPredicate() 7); } - [Fact] + [Test] public void FlattenPredicateAlwaysFalse() { var orig = new object[] @@ -132,7 +132,7 @@ public void FlattenPredicateAlwaysFalse() .AssertSequenceEqual(orig); } - [Fact] + [Test] public void FlattenPredicateAlwaysTrue() { using var source = new object[] @@ -163,13 +163,13 @@ public void FlattenPredicateAlwaysTrue() 6); } - [Fact] + [Test] public void FlattenPredicateIsLazy() { _ = new BreakingSequence().Flatten(BreakingFunc.Of()); } - [Fact] + [Test] public void FlattenFullIteratedDisposesInnerSequences() { using var inner1 = TestingSequence.Of(4, 5); @@ -181,7 +181,7 @@ public void FlattenFullIteratedDisposesInnerSequences() .AssertSequenceEqual(4, 5, 6, true, false, 7); } - [Fact] + [Test] public void FlattenInterruptedIterationDisposesInnerSequences() { using var inner1 = TestingSequence.Of(4, 5); @@ -193,7 +193,7 @@ public void FlattenInterruptedIterationDisposesInnerSequences() source.Flatten().Consume()); } - [Fact] + [Test] public void FlattenEvaluatesInnerSequencesLazily() { using var source = new object[] @@ -225,13 +225,13 @@ public void FlattenEvaluatesInnerSequencesLazily() // Flatten(this IEnumerable source, Func selector) - [Fact] + [Test] public void FlattenSelectorIsLazy() { _ = new BreakingSequence().Flatten(BreakingFunc.Of()); } - [Fact] + [Test] public void FlattenSelector() { using var source = new[] @@ -268,7 +268,7 @@ public void FlattenSelector() .AssertSequenceEqual("series1", 1, 2, 3, 4, "series2", 5, 6); } - [Fact] + [Test] public void FlattenSelectorFilteringOnlyIntegers() { using var source = new object[] @@ -300,7 +300,7 @@ public void FlattenSelectorFilteringOnlyIntegers() .AssertSequenceEqual(Enumerable.Range(1, 4).Cast()); } - [Fact] + [Test] public void FlattenSelectorWithTree() { var source = new Tree diff --git a/Tests/SuperLinq.Test/FoldTest.cs b/Tests/SuperLinq.Tests/FoldTest.cs similarity index 98% rename from Tests/SuperLinq.Test/FoldTest.cs rename to Tests/SuperLinq.Tests/FoldTest.cs index 53c69046a..2c46732ca 100644 --- a/Tests/SuperLinq.Test/FoldTest.cs +++ b/Tests/SuperLinq.Tests/FoldTest.cs @@ -1,29 +1,29 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class FoldTest { - [Fact] + [Test] public void FoldWithTooFewItems() { _ = Assert.Throws(() => Enumerable.Range(1, 3).Fold(BreakingFunc.Of())); } - [Fact] + [Test] public void FoldWithEmptySequence() { _ = Assert.Throws(() => Enumerable.Empty().Fold(BreakingFunc.Of())); } - [Fact] + [Test] public void FoldWithTooManyItems() { _ = Assert.Throws(() => Enumerable.Range(1, 3).Fold(BreakingFunc.Of())); } - [Fact] + [Test] public void Fold() { const string Alphabet = "abcdefghijklmnopqrstuvwxyz"; diff --git a/Tests/SuperLinq.Test/ForEachTest.cs b/Tests/SuperLinq.Tests/ForEachTest.cs similarity index 92% rename from Tests/SuperLinq.Test/ForEachTest.cs rename to Tests/SuperLinq.Tests/ForEachTest.cs index ba8548c02..8b0ad8c13 100644 --- a/Tests/SuperLinq.Test/ForEachTest.cs +++ b/Tests/SuperLinq.Tests/ForEachTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ForEachTest { - [Fact] + [Test] public void ForEachWithSequence() { using var seq = TestingSequence.Of(1, 2, 3); @@ -13,7 +13,7 @@ public void ForEachWithSequence() results.AssertSequenceEqual(1, 2, 3); } - [Fact] + [Test] public void ForEachIndexedWithSequence() { using var seq = TestingSequence.Of(9, 8, 7); diff --git a/Tests/SuperLinq.Test/FromTest.cs b/Tests/SuperLinq.Tests/FromTest.cs similarity index 90% rename from Tests/SuperLinq.Test/FromTest.cs rename to Tests/SuperLinq.Tests/FromTest.cs index 582c5ab8c..bc5580d69 100644 --- a/Tests/SuperLinq.Test/FromTest.cs +++ b/Tests/SuperLinq.Tests/FromTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class FromTest { - [Fact] + [Test] public void TestFromIsLazy() { var breakingFunc = BreakingFunc.Of(); @@ -12,11 +12,11 @@ public void TestFromIsLazy() _ = SuperEnumerable.From(breakingFunc, breakingFunc, breakingFunc, breakingFunc); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] public void TestFromInvokesMethods(int numArgs) { int F1() => -2; @@ -34,11 +34,11 @@ public void TestFromInvokesMethods(int numArgs) } } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] public void TestFromInvokesMethodsMultipleTimes(int numArgs) { var evals = new[] { 0, 0, 0, 0 }; diff --git a/Tests/SuperLinq.Test/FullGroupJoinTest.cs b/Tests/SuperLinq.Tests/FullGroupJoinTest.cs similarity index 88% rename from Tests/SuperLinq.Test/FullGroupJoinTest.cs rename to Tests/SuperLinq.Tests/FullGroupJoinTest.cs index 9a4bdca01..8012fe7e4 100644 --- a/Tests/SuperLinq.Test/FullGroupJoinTest.cs +++ b/Tests/SuperLinq.Tests/FullGroupJoinTest.cs @@ -1,10 +1,10 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class FullGroupJoinTest { public enum OverloadCase { CustomResult, TupleResult } - [Fact] + [Test] public void FullGroupIsLazy() { var bs = new BreakingSequence(); @@ -14,9 +14,9 @@ public void FullGroupIsLazy() _ = bs.FullGroupJoin(bs, bf, bf, bfg); } - [Theory] - [InlineData(OverloadCase.CustomResult)] - [InlineData(OverloadCase.TupleResult)] + [Test] + [Arguments(OverloadCase.CustomResult)] + [Arguments(OverloadCase.TupleResult)] public void FullGroupJoinsResults(OverloadCase overloadCase) { using var listA = TestingSequence.Of(1, 2); @@ -36,9 +36,9 @@ public void FullGroupJoinsResults(OverloadCase overloadCase) result[2].Second.AssertSequenceEqual(2); } - [Theory] - [InlineData(OverloadCase.CustomResult)] - [InlineData(OverloadCase.TupleResult)] + [Test] + [Arguments(OverloadCase.CustomResult)] + [Arguments(OverloadCase.TupleResult)] public void FullGroupJoinsEmptyLeft(OverloadCase overloadCase) { using var listA = Array.Empty().AsTestingSequence(); @@ -55,9 +55,9 @@ public void FullGroupJoinsEmptyLeft(OverloadCase overloadCase) Assert.Equal(3, result[3].Second.Single()); } - [Theory] - [InlineData(OverloadCase.CustomResult)] - [InlineData(OverloadCase.TupleResult)] + [Test] + [Arguments(OverloadCase.CustomResult)] + [Arguments(OverloadCase.TupleResult)] public void FullGroupJoinsEmptyRight(OverloadCase overloadCase) { using var listA = TestingSequence.Of(2, 3); @@ -74,9 +74,9 @@ public void FullGroupJoinsEmptyRight(OverloadCase overloadCase) Assert.Empty(result[3].Second); } - [Theory] - [InlineData(OverloadCase.CustomResult)] - [InlineData(OverloadCase.TupleResult)] + [Test] + [Arguments(OverloadCase.CustomResult)] + [Arguments(OverloadCase.TupleResult)] public void FullGroupPreservesOrder(OverloadCase overloadCase) { var listA = new[] diff --git a/Tests/SuperLinq.Test/FullOuterJoinTest.cs b/Tests/SuperLinq.Tests/FullOuterJoinTest.cs similarity index 86% rename from Tests/SuperLinq.Test/FullOuterJoinTest.cs rename to Tests/SuperLinq.Tests/FullOuterJoinTest.cs index 148f519af..210ce4de3 100644 --- a/Tests/SuperLinq.Test/FullOuterJoinTest.cs +++ b/Tests/SuperLinq.Tests/FullOuterJoinTest.cs @@ -1,6 +1,6 @@ -using static Test.JoinOperation; +using static SuperLinq.Tests.JoinOperation; -namespace Test; +namespace SuperLinq.Tests; public enum JoinOperation { None, Loop, Hash, Merge } @@ -10,7 +10,8 @@ public sealed class FullOuterJoinTest IEnumerable<(string, string)> left, IEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Hash, false) => left.FullOuterHashJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -21,10 +22,11 @@ public sealed class FullOuterJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetFullOuterJoins() => - new[] { Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetFullOuterJoins() => + new[] { Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public void FullOuterJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new BreakingSequence<(string, string)>(); @@ -33,7 +35,8 @@ public void FullOuterJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public void FullOuterJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -59,7 +62,8 @@ public void FullOuterJoinResults(JoinOperation op, bool passProjectors) (default, quux)); } - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public void FullOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -76,7 +80,8 @@ public void FullOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) (default, baz)); } - [Theory, MemberData(nameof(GetFullOuterJoins))] + [Test] + [MethodDataSource(nameof(GetFullOuterJoins))] public void FullOuterJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Test/FuncModule.cs b/Tests/SuperLinq.Tests/FuncModule.cs similarity index 96% rename from Tests/SuperLinq.Test/FuncModule.cs rename to Tests/SuperLinq.Tests/FuncModule.cs index c19fbaf7b..a80f69b26 100644 --- a/Tests/SuperLinq.Test/FuncModule.cs +++ b/Tests/SuperLinq.Tests/FuncModule.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; // This type is designed to be imported statically. // diff --git a/Tests/SuperLinq.Test/Future.cs b/Tests/SuperLinq.Tests/Future.cs similarity index 90% rename from Tests/SuperLinq.Test/Future.cs rename to Tests/SuperLinq.Tests/Future.cs index e8a154f3d..6eb9f5a8e 100644 --- a/Tests/SuperLinq.Test/Future.cs +++ b/Tests/SuperLinq.Tests/Future.cs @@ -1,6 +1,6 @@ #if !NETCOREAPP -namespace Test; +namespace SuperLinq.Tests; internal static class Future { diff --git a/Tests/SuperLinq.Test/GenerateTest.cs b/Tests/SuperLinq.Tests/GenerateTest.cs similarity index 91% rename from Tests/SuperLinq.Test/GenerateTest.cs rename to Tests/SuperLinq.Tests/GenerateTest.cs index 540f3e512..d3c6bf035 100644 --- a/Tests/SuperLinq.Test/GenerateTest.cs +++ b/Tests/SuperLinq.Tests/GenerateTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class GenerateTest { - [Fact] + [Test] public void GenerateTerminatesWhenCheckReturnsFalse() { var result = SuperEnumerable.Generate(1, n => n + 2).TakeWhile(n => n < 10); @@ -10,7 +10,7 @@ public void GenerateTerminatesWhenCheckReturnsFalse() result.AssertSequenceEqual(1, 3, 5, 7, 9); } - [Fact] + [Test] public void GenerateProcessesNonNumerics() { var result = SuperEnumerable.Generate("", s => s + 'a').TakeWhile(s => s.Length < 5); @@ -18,13 +18,13 @@ public void GenerateProcessesNonNumerics() result.AssertSequenceEqual("", "a", "aa", "aaa", "aaaa"); } - [Fact] + [Test] public void GenerateIsLazy() { _ = SuperEnumerable.Generate(0, BreakingFunc.Of()); } - [Fact] + [Test] public void GenerateFuncIsNotInvokedUnnecessarily() { SuperEnumerable.Generate(0, BreakingFunc.Of()) diff --git a/Tests/SuperLinq.Test/GetShortestPathTest.cs b/Tests/SuperLinq.Tests/GetShortestPathTest.cs similarity index 80% rename from Tests/SuperLinq.Test/GetShortestPathTest.cs rename to Tests/SuperLinq.Tests/GetShortestPathTest.cs index 8dac7681a..9b91c42e2 100644 --- a/Tests/SuperLinq.Test/GetShortestPathTest.cs +++ b/Tests/SuperLinq.Tests/GetShortestPathTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; public static class GetShortestPathTest { @@ -20,12 +20,12 @@ public static class GetShortestPathTest (from: "start", to: "END", cost: 10), (from: "start", to: "END", cost: 1000), }; + var map = costs .Concat(costs.Select(x => (from: x.to, to: x.from, x.cost))) - .Where(x => - x.to != "start" - && x.from != "end") + .Where(x => x is (not "end", not "start", _)) .ToLookup(x => x.from, x => (x.to, x.cost), stateComparer); + return map; } @@ -44,21 +44,27 @@ internal static void VerifySequences(this List> list) public sealed class Dijkstra { - public static IEnumerable GetStringIntCostData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + int expectedCost, + int expectedCount + )> GetStringIntCostData() => [ - [null, null, 15, 7,], - [StringComparer.InvariantCultureIgnoreCase, null, 10, 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1,], + (null, null, 15, 7), + (StringComparer.InvariantCultureIgnoreCase, null, 10, 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1), ]; - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public void GetStringIntCostByState( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -82,13 +88,14 @@ public void GetStringIntCostByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public void GetStringIntCostByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -114,21 +121,27 @@ public void GetStringIntCostByFunction( sequences.VerifySequences(); } - public static IEnumerable GetStringIntPathData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + IEnumerable<(string state, int cost)> expectedPath, + int expectedCount + )> GetStringIntPathData() => [ - [null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7,], - [StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1,], + (null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7), + (StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1), ]; - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public void GetStringIntPathByState( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -152,13 +165,14 @@ public void GetStringIntPathByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public void GetStringIntPathByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -184,12 +198,16 @@ public void GetStringIntPathByFunction( sequences.VerifySequences(); } - public static IEnumerable GetStringIntPathsData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + IEnumerable<(string state, (string? prevState, int cost))> expectedMap + )> GetStringIntPathsData() => [ - [ + ( null, null, - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 1)), ("b", ("a", 3)), @@ -200,23 +218,25 @@ public void GetStringIntPathByFunction( ("B", ("A", 30)), ("C", ("B", 60)), ("D", ("C", 100)), - ("END", ("start", 10))), - ], - [ + ("END", ("start", 10)), + ] + ), + ( StringComparer.InvariantCultureIgnoreCase, null, - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 1)), ("b", ("a", 3)), ("c", ("b", 6)), ("d", ("c", 10)), - ("end", ("start", 10))), - ], - [ + ("end", ("start", 10)), + ] + ), + ( null, Comparer.Create((x, y) => -x.CompareTo(y)), - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 1)), ("b", ("a", 3)), @@ -227,27 +247,30 @@ public void GetStringIntPathByFunction( ("C", ("B", 60)), ("D", ("C", 100)), ("end", ("D", 150)), - ("END", ("start", 1000))), - ], - [ + ("END", ("start", 1000)), + ] + ), + ( StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), - Seq<(string, (string?, int))>( + [ ("start", (null, 0)), ("a", ("start", 10)), ("b", ("a", 30)), ("c", ("b", 60)), ("d", ("c", 100)), - ("end", ("start", 1000))), - ], + ("end", ("start", 1000)), + ] + ), ]; - [Theory] - [MemberData(nameof(GetStringIntPathsData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathsData))] public void GetStringIntPaths( IEqualityComparer? stateComparer, IComparer? costComparer, - IEnumerable<(string state, (string? prevState, int cost))> expectedMap) + IEnumerable<(string state, (string? prevState, int cost))> expectedMap + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -278,7 +301,7 @@ public void GetStringIntPaths( sequences.VerifySequences(); } - [Fact] + [Test] public void GetRegularMapCost() { var count = 0; @@ -304,7 +327,7 @@ public void GetRegularMapCost() sequences.VerifySequences(); } - [Fact] + [Test] public void GetRegularMapPath() { var count = 0; @@ -335,7 +358,7 @@ public void GetRegularMapPath() sequences.VerifySequences(); } - [Fact] + [Test] public void InvalidMapThrowsException() { _ = Assert.Throws(() => @@ -347,24 +370,30 @@ public void InvalidMapThrowsException() public sealed class AStar { - public static IEnumerable GetStringIntCostData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + int expectedCost, + int expectedCount + )> GetStringIntCostData() => [ - [null, null, 15, 7,], - [StringComparer.InvariantCultureIgnoreCase, null, 10, 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1,], + (null, null, 15, 7), + (StringComparer.InvariantCultureIgnoreCase, null, 10, 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), 150, 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), 1000, 1), ]; // No heuristic means this operates the same as Dijkstra; this is // to prove the base algorithm still works. // Primary improvement of A* is the heuristic to reduce nodes visited. - [Theory] - [MemberData(nameof(GetStringIntCostData))] + [Test] + [MethodDataSource(nameof(GetStringIntCostData))] public void GetStringIntCost( IEqualityComparer? stateComparer, IComparer? costComparer, int expectedCost, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -388,24 +417,30 @@ public void GetStringIntCost( sequences.VerifySequences(); } - public static IEnumerable GetStringIntPathData { get; } = + public static IEnumerable<( + IEqualityComparer? stateComparer, + IComparer? costComparer, + IEnumerable<(string state, int cost)> expectedPath, + int expectedCount + )> GetStringIntPathData() => [ - [null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7,], - [StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4,], - [null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6,], - [StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1,], + (null, null, Seq(("start", 0), ("a", 1), ("b", 3), ("c", 6), ("d", 10), ("end", 15)), 7), + (StringComparer.InvariantCultureIgnoreCase, null, Seq(("start", 0), ("END", 10)), 4), + (null, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("A", 10), ("B", 30), ("C", 60), ("D", 100), ("end", 150)), 6), + (StringComparer.InvariantCultureIgnoreCase, Comparer.Create((x, y) => -x.CompareTo(y)), Seq(("start", 0), ("END", 1000)), 1), ]; // No heuristic means this operates the same as Dijkstra; this is // to prove the base algorithm still works. // Primary improvement of A* is the heuristic to reduce nodes visited. - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public void GetStringIntPathByState( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { var map = BuildStringIntMap(stateComparer); var count = 0; @@ -429,13 +464,14 @@ public void GetStringIntPathByState( sequences.VerifySequences(); } - [Theory] - [MemberData(nameof(GetStringIntPathData))] + [Test] + [MethodDataSource(nameof(GetStringIntPathData))] public void GetStringIntPathByFunction( IEqualityComparer? stateComparer, IComparer? costComparer, IEnumerable<(string state, int cost)> expectedPath, - int expectedCount) + int expectedCount + ) { stateComparer ??= EqualityComparer.Default; @@ -461,7 +497,7 @@ public void GetStringIntPathByFunction( sequences.VerifySequences(); } - [Fact] + [Test] public void GetRegularMapCost() { var start = (x: 0, y: 0); @@ -497,7 +533,7 @@ public void GetRegularMapCost() sequences.VerifySequences(); } - [Fact] + [Test] public void GetRegularMapPath() { var start = (x: 0, y: 0); @@ -539,7 +575,7 @@ public void GetRegularMapPath() sequences.VerifySequences(); } - [Fact] + [Test] public void InvalidMapThrowsException() { _ = Assert.Throws(() => diff --git a/Tests/SuperLinq.Test/GroupAdjacentTest.cs b/Tests/SuperLinq.Tests/GroupAdjacentTest.cs similarity index 98% rename from Tests/SuperLinq.Test/GroupAdjacentTest.cs rename to Tests/SuperLinq.Tests/GroupAdjacentTest.cs index 3b23641c0..a0dcf6566 100644 --- a/Tests/SuperLinq.Test/GroupAdjacentTest.cs +++ b/Tests/SuperLinq.Tests/GroupAdjacentTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class GroupAdjacentTest { - [Fact] + [Test] public void GroupAdjacentIsLazy() { var bs = new BreakingSequence(); @@ -18,7 +18,7 @@ public void GroupAdjacentIsLazy() _ = bs.GroupAdjacent(bf, bfg, EqualityComparer.Default); } - [Fact] + [Test] public void GroupAdjacentSourceSequence() { const string One = "one"; @@ -47,7 +47,7 @@ public void GroupAdjacentSourceSequence() reader.ReadEnd(); } - [Fact] + [Test] public void GroupAdjacentSourceSequenceComparer() { using var source = TestingSequence.Of("foo", "FOO", "Foo", "bar", "BAR", "Bar"); @@ -60,7 +60,7 @@ public void GroupAdjacentSourceSequenceComparer() reader.ReadEnd(); } - [Fact] + [Test] public void GroupAdjacentSourceSequenceElementSelector() { using var source = TestingSequence.Of( @@ -87,7 +87,7 @@ public void GroupAdjacentSourceSequenceElementSelector() reader.ReadEnd(); } - [Fact] + [Test] public void GroupAdjacentSourceSequenceElementSelectorComparer() { using var source = TestingSequence.Of( @@ -114,7 +114,7 @@ public void GroupAdjacentSourceSequenceElementSelectorComparer() reader.ReadEnd(); } - [Fact] + [Test] public void GroupAdjacentSourceSequenceResultSelector() { using var source = TestingSequence.Of( @@ -141,7 +141,7 @@ public void GroupAdjacentSourceSequenceResultSelector() reader.ReadEnd(); } - [Fact] + [Test] public void GroupAdjacentSourceSequenceResultSelectorComparer() { using var source = TestingSequence.Of( @@ -168,7 +168,7 @@ public void GroupAdjacentSourceSequenceResultSelectorComparer() reader.ReadEnd(); } - [Fact] + [Test] public void GroupAdjacentSourceSequenceWithSomeNullKeys() { using var source = Enumerable.Range(1, 5) diff --git a/Tests/SuperLinq.Tests/HasDuplicatesTest.cs b/Tests/SuperLinq.Tests/HasDuplicatesTest.cs new file mode 100644 index 000000000..bb8177908 --- /dev/null +++ b/Tests/SuperLinq.Tests/HasDuplicatesTest.cs @@ -0,0 +1,43 @@ +namespace SuperLinq.Tests; + +public sealed class HasDuplicatesTest +{ + [Test] + public void DuplicatesDoesNotEnumerateUnnecessarily() + { + using var ts = Seq(1, 2, 3).Concat(SeqExceptionAt(2)).AsTestingSequence(); + + var result = ts.HasDuplicates(); + Assert.True(result); + } + + [Test] + [Arguments(new int[] { 1, 2, 3 }, false)] + [Arguments(new int[] { 1, 2, 1, 3, 1, 2, 1 }, true)] + [Arguments(new int[] { 3, 3, 2, 2, 1, 1 }, true)] + public void DuplicatesBehavior(IEnumerable source, bool expected) + { + using var ts = source.AsTestingSequence(); + + var result = ts.HasDuplicates(); + Assert.Equal(expected, result); + } + + public static IEnumerable<(IEnumerable source, StringComparer comparer, bool expected)> GetStringParameters() => + [ + (["foo", "bar", "qux"], StringComparer.Ordinal, false), + (["foo", "FOO", "bar", "qux"], StringComparer.Ordinal, false), + (["foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, true), + (["Bar", "foo", "FOO", "bar", "qux"], StringComparer.OrdinalIgnoreCase, true), + ]; + + [Test] + [MethodDataSource(nameof(GetStringParameters))] + public void DuplicatesComparerBehavior(IEnumerable source, StringComparer comparer, bool expected) + { + using var ts = source.AsTestingSequence(); + + var result = ts.HasDuplicates(comparer); + Assert.Equal(expected, result); + } +} diff --git a/Tests/SuperLinq.Test/IDisposableEnumerator.cs b/Tests/SuperLinq.Tests/IDisposableEnumerator.cs similarity index 89% rename from Tests/SuperLinq.Test/IDisposableEnumerator.cs rename to Tests/SuperLinq.Tests/IDisposableEnumerator.cs index 63bb993c4..feaff5bab 100644 --- a/Tests/SuperLinq.Test/IDisposableEnumerator.cs +++ b/Tests/SuperLinq.Tests/IDisposableEnumerator.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Used to identify enumerables that can and should be disposed, such as . diff --git a/Tests/SuperLinq.Test/IfTest.cs b/Tests/SuperLinq.Tests/IfTest.cs similarity index 94% rename from Tests/SuperLinq.Test/IfTest.cs rename to Tests/SuperLinq.Tests/IfTest.cs index c7ddaa202..1f5f8310d 100644 --- a/Tests/SuperLinq.Test/IfTest.cs +++ b/Tests/SuperLinq.Tests/IfTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class IfTest { - [Fact] + [Test] public void IfIsLazy() { _ = SuperEnumerable.If(BreakingFunc.Of(), new BreakingSequence()); } - [Fact] + [Test] public void IfBehavior() { var starts = 0; @@ -25,7 +25,7 @@ public void IfBehavior() seq.AssertSequenceEqual(); } - [Fact] + [Test] public void IfElseIsLazy() { _ = SuperEnumerable.If( @@ -34,7 +34,7 @@ public void IfElseIsLazy() new BreakingSequence()); } - [Fact] + [Test] public void CaseSourceBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Test/IndexByTest.cs b/Tests/SuperLinq.Tests/IndexByTest.cs similarity index 96% rename from Tests/SuperLinq.Test/IndexByTest.cs rename to Tests/SuperLinq.Tests/IndexByTest.cs index c300bdd0f..8ae575b78 100644 --- a/Tests/SuperLinq.Test/IndexByTest.cs +++ b/Tests/SuperLinq.Tests/IndexByTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class IndexByTest { - [Fact] + [Test] public void IndexBySimpleTest() { using var source = TestingSequence.Of("ana", "beatriz", "carla", "bob", "davi", "adriano", "angelo", "carlos"); @@ -19,7 +19,7 @@ public void IndexBySimpleTest() (1, "carlos")); } - [Fact] + [Test] public void IndexByWithSecondOccurenceImmediatelyAfterFirst() { using var source = "jaffer".AsTestingSequence(); @@ -28,7 +28,7 @@ public void IndexByWithSecondOccurenceImmediatelyAfterFirst() result.AssertSequenceEqual((0, 'j'), (0, 'a'), (0, 'f'), (1, 'f'), (0, 'e'), (0, 'r')); } - [Fact] + [Test] public void IndexByWithEqualityComparer() { using var source = TestingSequence.Of("a", "B", "c", "A", "b", "A"); @@ -37,13 +37,13 @@ public void IndexByWithEqualityComparer() result.AssertSequenceEqual((0, "a"), (0, "B"), (0, "c"), (1, "A"), (1, "b"), (2, "A")); } - [Fact] + [Test] public void IndexByIsLazy() { _ = new BreakingSequence().IndexBy(BreakingFunc.Of()); } - [Fact] + [Test] public void IndexByWithSomeNullKeys() { using var source = TestingSequence.Of("foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"); @@ -52,7 +52,7 @@ public void IndexByWithSomeNullKeys() result.AssertSequenceEqual((0, "foo"), (0, null), (0, "bar"), (0, "baz"), (1, null), (2, null), (1, "baz"), (1, "bar"), (3, null), (1, "foo")); } - [Fact] + [Test] public void IndexBytDoesNotIterateUnnecessaryElements() { using var source = SuperEnumerable diff --git a/Tests/SuperLinq.Test/IndexOfTest.cs b/Tests/SuperLinq.Tests/IndexOfTest.cs similarity index 95% rename from Tests/SuperLinq.Test/IndexOfTest.cs rename to Tests/SuperLinq.Tests/IndexOfTest.cs index e1b771899..baa78685f 100644 --- a/Tests/SuperLinq.Test/IndexOfTest.cs +++ b/Tests/SuperLinq.Tests/IndexOfTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class IndexOfTest { - [Fact] + [Test] public void IndexOfWithNegativeCount() { using var sequence = TestingSequence.Of(1); @@ -12,14 +12,14 @@ public void IndexOfWithNegativeCount() sequence.IndexOf(1, 1, -1)); } - [Fact] + [Test] public void IndexOfWorksWithEmptySequence() { using var sequence = Array.Empty().AsTestingSequence(); Assert.Equal(-1, sequence.IndexOf(5)); } - [Fact] + [Test] public void IndexOfFromStart() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -28,7 +28,7 @@ public void IndexOfFromStart() sequence.IndexOf(102)); } - [Fact] + [Test] public void IndexOfFromStartCount() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -37,7 +37,7 @@ public void IndexOfFromStartCount() sequence.IndexOf(102, 0, 3)); } - [Fact] + [Test] public void IndexOfFromStartIndex() { using var sequence = Enumerable.Range(100, 5).Concat(Enumerable.Range(100, 5)).AsTestingSequence(); @@ -46,7 +46,7 @@ public void IndexOfFromStartIndex() sequence.IndexOf(102, 5)); } - [Fact] + [Test] public void IndexOfFromEndIndex() { using var sequence = Enumerable.Range(100, 5).Concat(Enumerable.Range(100, 5)).AsTestingSequence(); @@ -55,7 +55,7 @@ public void IndexOfFromEndIndex() sequence.IndexOf(102, ^5)); } - [Fact] + [Test] public void IndexOfFromEndOfArray() { var array = new int[20]; @@ -65,7 +65,7 @@ public void IndexOfFromEndOfArray() array.IndexOf(3, ^5)); } - [Fact] + [Test] public void IndexOfMissingValueFromStart() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -74,7 +74,7 @@ public void IndexOfMissingValueFromStart() sequence.IndexOf(95)); } - [Fact] + [Test] public void IndexOfMissingValueFromEnd() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -83,7 +83,7 @@ public void IndexOfMissingValueFromEnd() sequence.IndexOf(95, ^5)); } - [Fact] + [Test] public void IndexOfMissingValueFromStartCount() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -92,7 +92,7 @@ public void IndexOfMissingValueFromStartCount() sequence.IndexOf(104, 0, 4)); } - [Fact] + [Test] public void IndexOfMissingValueFromEndCount() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -101,7 +101,7 @@ public void IndexOfMissingValueFromEndCount() sequence.IndexOf(104, ^5, 4)); } - [Fact] + [Test] public void IndexOfDoesNotIterateUnnecessaryElements() { using var source = SuperEnumerable @@ -119,7 +119,7 @@ public void IndexOfDoesNotIterateUnnecessaryElements() Assert.Equal(4, source.IndexOf("davi")); } - [Fact] + [Test] public void IndexOfDoesNotIterateUnnecessaryElementsCount() { using var source = SuperEnumerable diff --git a/Tests/SuperLinq.Test/IndexTest.cs b/Tests/SuperLinq.Tests/IndexTest.cs similarity index 84% rename from Tests/SuperLinq.Test/IndexTest.cs rename to Tests/SuperLinq.Tests/IndexTest.cs index 8b65377d1..7e49e2f66 100644 --- a/Tests/SuperLinq.Test/IndexTest.cs +++ b/Tests/SuperLinq.Tests/IndexTest.cs @@ -1,9 +1,9 @@ -namespace Test; +namespace SuperLinq.Tests; [Obsolete("References `Index` which is obsolete in net9+")] public sealed class IndexTest { - [Fact] + [Test] public void IndexIsLazy() { _ = SuperEnumerable.Index(new BreakingSequence()); @@ -14,13 +14,12 @@ public void IndexIsLazy() private const string Two = "two"; private const string Three = "three"; - public static IEnumerable GetSequences() => + public static IEnumerable> GetSequences() => Seq(One, Two, Three) - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void IndexSequence(IDisposableEnumerable seq) { using (seq) @@ -33,8 +32,8 @@ public void IndexSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void IndexSequenceStartIndex(IDisposableEnumerable seq) { using (seq) @@ -47,7 +46,7 @@ public void IndexSequenceStartIndex(IDisposableEnumerable seq) } } - [Fact] + [Test] public void IndexCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -56,7 +55,7 @@ public void IndexCollectionBehavior() result.AssertCollectionErrorChecking(10_000); } - [Fact] + [Test] public void IndexListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/InnerJoinTest.cs b/Tests/SuperLinq.Tests/InnerJoinTest.cs similarity index 85% rename from Tests/SuperLinq.Test/InnerJoinTest.cs rename to Tests/SuperLinq.Tests/InnerJoinTest.cs index b6636edaa..3d66ba2f8 100644 --- a/Tests/SuperLinq.Test/InnerJoinTest.cs +++ b/Tests/SuperLinq.Tests/InnerJoinTest.cs @@ -1,6 +1,6 @@ -using static Test.JoinOperation; +using static SuperLinq.Tests.JoinOperation; -namespace Test; +namespace SuperLinq.Tests; public sealed class InnerJoinTest { @@ -8,7 +8,8 @@ public sealed class InnerJoinTest IEnumerable<(string, string)> left, IEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Loop, false) => left.InnerLoopJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -21,10 +22,11 @@ public sealed class InnerJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetInnerJoins() => - new[] { Loop, Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetInnerJoins() => + new[] { Loop, Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public void InnerJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new BreakingSequence<(string, string)>(); @@ -33,7 +35,8 @@ public void InnerJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public void InnerJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -54,7 +57,8 @@ public void InnerJoinResults(JoinOperation op, bool passProjectors) (bar1, bar3)); } - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public void InnerJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -68,7 +72,8 @@ public void InnerJoinEmptyLeft(JoinOperation op, bool passProjectors) result.AssertCollectionEqual(); } - [Theory, MemberData(nameof(GetInnerJoins))] + [Test] + [MethodDataSource(nameof(GetInnerJoins))] public void InnerJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Test/InsertTest.cs b/Tests/SuperLinq.Tests/InsertTest.cs similarity index 80% rename from Tests/SuperLinq.Test/InsertTest.cs rename to Tests/SuperLinq.Tests/InsertTest.cs index 15e8df649..7f11319a5 100644 --- a/Tests/SuperLinq.Test/InsertTest.cs +++ b/Tests/SuperLinq.Tests/InsertTest.cs @@ -2,17 +2,17 @@ using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; public sealed class InsertTest { - [Fact] + [Test] public void InsertIsLazy() { _ = new BreakingSequence().Insert(new BreakingSequence(), 0); } - [Fact] + [Test] public void InsertWithNegativeIndex() { _ = Assert.Throws(() => @@ -24,24 +24,28 @@ public void InsertWithNegativeIndex() "CA2000:Dispose objects before losing scope", Justification = "Will be properly disposed in method" )] - public static IEnumerable GetSequences() + public static IEnumerable<( + IDisposableEnumerable seq1, + IDisposableEnumerable seq2 + )> GetSequences() { var baseSeq = Enumerable.Range(0, 10); var insSeq = Seq(97, 98, 99); return [ - [baseSeq.AsTestingSequence(), insSeq.AsTestingSequence(),], - [baseSeq.AsTestingCollection(), insSeq.AsTestingCollection(),], - [baseSeq.AsBreakingList(), insSeq.AsBreakingList(),], + (baseSeq.AsTestingSequence(), insSeq.AsTestingSequence()), + (baseSeq.AsTestingCollection(), insSeq.AsTestingCollection()), + (baseSeq.AsBreakingList(), insSeq.AsBreakingList()), ]; } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void InsertWithIndexGreaterThanSourceLength( IDisposableEnumerable seq1, - IDisposableEnumerable seq2) + IDisposableEnumerable seq2 + ) { using (seq1) using (seq2) @@ -55,8 +59,8 @@ public void InsertWithIndexGreaterThanSourceLength( } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void InsertWithEndIndexGreaterThanSourceLength( IDisposableEnumerable seq1, IDisposableEnumerable seq2) @@ -73,18 +77,24 @@ public void InsertWithEndIndexGreaterThanSourceLength( } } - public static IEnumerable GetInsertData() => + public static IEnumerable<( + IDisposableEnumerable seq1, + IDisposableEnumerable seq2, + Index index + )> GetInsertData() => Seq(0, 5, 10, ^0, ^5, ^10) .SelectMany( _ => GetSequences(), - (i, x) => new object[] { x[0], x[1], i }); + (i, x) => (x.seq1, x.seq2, i) + ); - [Theory] - [MemberData(nameof(GetInsertData))] + [Test] + [MethodDataSource(nameof(GetInsertData))] public void Insert( IDisposableEnumerable seq1, IDisposableEnumerable seq2, - Index index) + Index index + ) { using (seq1) using (seq2) @@ -96,11 +106,12 @@ public void Insert( Enumerable.Range(0, idx) .Concat(Seq(97, 98, 99)) .Concat(Enumerable.Range(idx, 10 - idx)), - testCollectionEnumerable: true); + testCollectionEnumerable: true + ); } } - [Fact] + [Test] public void InsertCollectionBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -110,7 +121,7 @@ public void InsertCollectionBehavior() result.AssertCollectionErrorChecking(20_000); } - [Fact] + [Test] public void InsertListFromStartBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -125,7 +136,7 @@ public void InsertListFromStartBehavior() Assert.Equal(8_800, result.ElementAt(^1_200)); } - [Fact] + [Test] public void InsertListFromEndBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -140,7 +151,7 @@ public void InsertListFromEndBehavior() Assert.Equal(8_800, result.ElementAt(^1_200)); } - [Fact] + [Test] public void InsertListAtEndBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/InterleaveTest.cs b/Tests/SuperLinq.Tests/InterleaveTest.cs similarity index 97% rename from Tests/SuperLinq.Test/InterleaveTest.cs rename to Tests/SuperLinq.Tests/InterleaveTest.cs index 17dc52d06..68cf43b58 100644 --- a/Tests/SuperLinq.Test/InterleaveTest.cs +++ b/Tests/SuperLinq.Tests/InterleaveTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Interleave operator @@ -8,7 +8,7 @@ public sealed class InterleaveTest /// /// Verify that Interleave behaves in a lazy manner /// - [Fact] + [Test] public void TestInterleaveIsLazy() { _ = new BreakingSequence().Interleave(new BreakingSequence()); @@ -18,7 +18,7 @@ public void TestInterleaveIsLazy() /// Verify that interleaving disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public void TestInterleaveDisposesOnErrorAtGetEnumerator() { using var sequenceA = TestingSequence.Of(); @@ -32,7 +32,7 @@ public void TestInterleaveDisposesOnErrorAtGetEnumerator() /// Verify that interleaving disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public void TestInterleaveDisposesOnErrorAtMoveNext() { using var sequenceA = TestingSequence.Of(); @@ -45,7 +45,7 @@ public void TestInterleaveDisposesOnErrorAtMoveNext() /// /// Verify that interleaving do not call enumerators MoveNext method eagerly /// - [Fact] + [Test] public void TestInterleaveDoNoCallMoveNextEagerly() { using var sequenceA = Enumerable.Range(1, 1).AsTestingSequence(); @@ -57,7 +57,7 @@ public void TestInterleaveDoNoCallMoveNextEagerly() /// /// Verify that two balanced sequences will interleave all of their elements /// - [Fact] + [Test] public void TestInterleaveTwoBalancedSequences() { using var sequenceA = Enumerable.Range(1, 10).AsTestingSequence(); @@ -70,7 +70,7 @@ public void TestInterleaveTwoBalancedSequences() /// /// Verify that interleaving two empty sequences results in an empty sequence /// - [Fact] + [Test] public void TestInterleaveTwoEmptySequences() { using var sequenceA = TestingSequence.Of(); @@ -84,7 +84,7 @@ public void TestInterleaveTwoEmptySequences() /// Verify that interleaving two unequal sequences with the Skip strategy results in /// the shorter sequence being omitted from the interleave operation when consumed /// - [Fact] + [Test] public void TestInterleaveTwoImbalanceStrategySkip() { using var sequenceA = TestingSequence.Of(0, 0, 0, 0, 0, 0); @@ -97,7 +97,7 @@ public void TestInterleaveTwoImbalanceStrategySkip() /// /// Verify that interleaving multiple empty sequences results in an empty sequence /// - [Fact] + [Test] public void TestInterleaveManyEmptySequences() { using var sequenceA = TestingSequence.Of(); @@ -114,7 +114,7 @@ public void TestInterleaveManyEmptySequences() /// Verify that interleaving multiple unequal sequences with the Skip strategy /// results in sequences being omitted form the interleave operation when consumed /// - [Fact] + [Test] public void TestInterleaveManyImbalanceStrategySkip() { using var sequenceA = TestingSequence.Of(1, 5, 8, 11, 14, 16); @@ -129,7 +129,7 @@ public void TestInterleaveManyImbalanceStrategySkip() result.AssertSequenceEqual(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17); } - [Fact] + [Test] public void TestInterleaveCollectionCount() { using var sequenceA = Enumerable.Range(1, 10_000).AsBreakingCollection(); diff --git a/Tests/SuperLinq.Test/LagTest.cs b/Tests/SuperLinq.Tests/LagTest.cs similarity index 83% rename from Tests/SuperLinq.Test/LagTest.cs rename to Tests/SuperLinq.Tests/LagTest.cs index 594c1bc7b..79f9b09dd 100644 --- a/Tests/SuperLinq.Test/LagTest.cs +++ b/Tests/SuperLinq.Tests/LagTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Lag operator @@ -8,7 +8,7 @@ public sealed class LagTest /// /// Verify that lag behaves in a lazy manner. /// - [Fact] + [Test] public void TestLagIsLazy() { _ = new BreakingSequence().Lag(5, BreakingFunc.Of()); @@ -18,7 +18,7 @@ public void TestLagIsLazy() /// /// Verify that lagging by a negative offset results in an exception. /// - [Fact] + [Test] public void TestLagNegativeOffsetException() { _ = Assert.Throws(() => @@ -28,20 +28,19 @@ public void TestLagNegativeOffsetException() /// /// Verify that attempting to lag by a zero offset will result in an exception /// - [Fact] + [Test] public void TestLagZeroOffset() { _ = Assert.Throws(() => new BreakingSequence().Lag(0, (val, lagVal) => val + lagVal)); } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Enumerable.Range(1, 100) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLagExplicitDefaultValue(IDisposableEnumerable seq) { using (seq) @@ -52,8 +51,8 @@ public void TestLagExplicitDefaultValue(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLagTuple(IDisposableEnumerable seq) { using (seq) @@ -64,8 +63,8 @@ public void TestLagTuple(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLagImplicitDefaultValue(IDisposableEnumerable seq) { using (seq) @@ -77,8 +76,8 @@ public void TestLagImplicitDefaultValue(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLagOffsetGreaterThanSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -89,8 +88,8 @@ public void TestLagOffsetGreaterThanSequenceLength(IDisposableEnumerable se } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLagPassesCorrectLagValueOffsetBy1(IDisposableEnumerable seq) { using (seq) @@ -102,8 +101,8 @@ public void TestLagPassesCorrectLagValueOffsetBy1(IDisposableEnumerable seq } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLagPassesCorrectLagValuesOffsetBy2(IDisposableEnumerable seq) { using (seq) @@ -115,13 +114,12 @@ public void TestLagPassesCorrectLagValuesOffsetBy2(IDisposableEnumerable se } } - public static IEnumerable GetStringSequences() => + public static IEnumerable> GetStringSequences() => Seq("foo", "bar", "baz", "qux") - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetStringSequences))] + [Test] + [MethodDataSource(nameof(GetStringSequences))] public void TestLagWithNullableReferences(IDisposableEnumerable seq) { using (seq) @@ -135,8 +133,8 @@ public void TestLagWithNullableReferences(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetStringSequences))] + [Test] + [MethodDataSource(nameof(GetStringSequences))] public void TestLagWithNonNullableReferences(IDisposableEnumerable seq) { using (seq) @@ -150,7 +148,7 @@ public void TestLagWithNonNullableReferences(IDisposableEnumerable seq) } } - [Fact] + [Test] public void LagListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/LastIndexOfTest.cs b/Tests/SuperLinq.Tests/LastIndexOfTest.cs similarity index 95% rename from Tests/SuperLinq.Test/LastIndexOfTest.cs rename to Tests/SuperLinq.Tests/LastIndexOfTest.cs index db92bc034..35e6afc5b 100644 --- a/Tests/SuperLinq.Test/LastIndexOfTest.cs +++ b/Tests/SuperLinq.Tests/LastIndexOfTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class LastIndexOfTest { - [Fact] + [Test] public void LastIndexOfWithNegativeCount() { using var sequence = TestingSequence.Of(1); @@ -12,14 +12,14 @@ public void LastIndexOfWithNegativeCount() sequence.LastIndexOf(1, 1, -1)); } - [Fact] + [Test] public void LastIndexOfWorksWithEmptySequence() { using var sequence = Array.Empty().AsTestingSequence(); Assert.Equal(-1, sequence.LastIndexOf(5)); } - [Fact] + [Test] public void LastIndexOfFromStart() { using var sequence = Enumerable.Range(100, 5) @@ -30,7 +30,7 @@ public void LastIndexOfFromStart() sequence.LastIndexOf(102)); } - [Fact] + [Test] public void LastIndexOfFromStartCount() { using var sequence = Enumerable.Range(100, 5) @@ -41,7 +41,7 @@ public void LastIndexOfFromStartCount() sequence.LastIndexOf(102, int.MaxValue, 8)); } - [Fact] + [Test] public void LastIndexOfFromStartIndex() { using var sequence = Enumerable.Range(100, 5) @@ -52,7 +52,7 @@ public void LastIndexOfFromStartIndex() sequence.LastIndexOf(102, 8)); } - [Fact] + [Test] public void LastIndexOfFromEndIndex() { using var sequence = Enumerable.Range(100, 5) @@ -63,7 +63,7 @@ public void LastIndexOfFromEndIndex() sequence.LastIndexOf(102, ^3)); } - [Fact] + [Test] public void LastIndexOfFromEndOfArray() { var array = new int[20]; @@ -74,7 +74,7 @@ public void LastIndexOfFromEndOfArray() array.LastIndexOf(3, ^5)); } - [Fact] + [Test] public void LastIndexOfMissingValueFromStart() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -83,7 +83,7 @@ public void LastIndexOfMissingValueFromStart() sequence.LastIndexOf(95)); } - [Fact] + [Test] public void LastIndexOfMissingValueFromEnd() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -92,7 +92,7 @@ public void LastIndexOfMissingValueFromEnd() sequence.LastIndexOf(95, ^5)); } - [Fact] + [Test] public void LastIndexOfMissingValueFromStartCount() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); @@ -101,7 +101,7 @@ public void LastIndexOfMissingValueFromStartCount() sequence.LastIndexOf(100, int.MaxValue, 4)); } - [Fact] + [Test] public void LastIndexOfMissingValueFromEndCount() { using var sequence = Enumerable.Range(100, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/LeadTest.cs b/Tests/SuperLinq.Tests/LeadTest.cs similarity index 83% rename from Tests/SuperLinq.Test/LeadTest.cs rename to Tests/SuperLinq.Tests/LeadTest.cs index 6fb5e53eb..05439d215 100644 --- a/Tests/SuperLinq.Test/LeadTest.cs +++ b/Tests/SuperLinq.Tests/LeadTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Lead operator. @@ -8,7 +8,7 @@ public sealed class LeadTest /// /// Verify that Lead() behaves in a lazy manner. /// - [Fact] + [Test] public void TestLeadIsLazy() { _ = new BreakingSequence().Lead(5, BreakingFunc.Of()); @@ -18,7 +18,7 @@ public void TestLeadIsLazy() /// /// Verify that attempting to lead by a negative offset will result in an exception. /// - [Fact] + [Test] public void TestLeadNegativeOffset() { _ = Assert.Throws(() => @@ -28,20 +28,19 @@ public void TestLeadNegativeOffset() /// /// Verify that attempting to lead by a zero offset will result in an exception. /// - [Fact] + [Test] public void TestLeadZeroOffset() { _ = Assert.Throws(() => new BreakingSequence().Lead(0, (val, leadVal) => val + leadVal)); } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Enumerable.Range(1, 100) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLeadExplicitDefaultValue(IDisposableEnumerable seq) { using (seq) @@ -53,8 +52,8 @@ public void TestLeadExplicitDefaultValue(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLeadTuple(IDisposableEnumerable seq) { using (seq) @@ -66,8 +65,8 @@ public void TestLeadTuple(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLeadImplicitDefaultValue(IDisposableEnumerable seq) { using (seq) @@ -79,8 +78,8 @@ public void TestLeadImplicitDefaultValue(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLeadOffsetGreaterThanSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -92,8 +91,8 @@ public void TestLeadOffsetGreaterThanSequenceLength(IDisposableEnumerable s } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLeadPassesCorrectValueOffsetBy1(IDisposableEnumerable seq) { using (seq) @@ -105,8 +104,8 @@ public void TestLeadPassesCorrectValueOffsetBy1(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void TestLeadPassesCorrectValueOffsetBy2(IDisposableEnumerable seq) { using (seq) @@ -118,13 +117,12 @@ public void TestLeadPassesCorrectValueOffsetBy2(IDisposableEnumerable seq) } } - public static IEnumerable GetStringSequences() => + public static IEnumerable> GetStringSequences() => Seq("foo", "bar", "baz", "qux") - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetStringSequences))] + [Test] + [MethodDataSource(nameof(GetStringSequences))] public void TestLagWithNullableReferences(IDisposableEnumerable seq) { using (seq) @@ -138,8 +136,8 @@ public void TestLagWithNullableReferences(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetStringSequences))] + [Test] + [MethodDataSource(nameof(GetStringSequences))] public void TestLagWithNonNullableReferences(IDisposableEnumerable seq) { using (seq) @@ -153,7 +151,7 @@ public void TestLagWithNonNullableReferences(IDisposableEnumerable seq) } } - [Fact] + [Test] public void LeadListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/LeftOuterJoin.cs b/Tests/SuperLinq.Tests/LeftOuterJoin.cs similarity index 86% rename from Tests/SuperLinq.Test/LeftOuterJoin.cs rename to Tests/SuperLinq.Tests/LeftOuterJoin.cs index 6acdc2e18..5d2aeb075 100644 --- a/Tests/SuperLinq.Test/LeftOuterJoin.cs +++ b/Tests/SuperLinq.Tests/LeftOuterJoin.cs @@ -1,6 +1,6 @@ -using static Test.JoinOperation; +using static SuperLinq.Tests.JoinOperation; -namespace Test; +namespace SuperLinq.Tests; public sealed class LeftOuterJoinTest { @@ -8,7 +8,8 @@ public sealed class LeftOuterJoinTest IEnumerable<(string, string)> left, IEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Loop, false) => left.LeftOuterLoopJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -21,10 +22,11 @@ public sealed class LeftOuterJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetLeftOuterJoins() => - new[] { Loop, Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetLeftOuterJoins() => + new[] { Loop, Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public void LeftOuterJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new BreakingSequence<(string, string)>(); @@ -33,7 +35,8 @@ public void LeftOuterJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public void LeftOuterJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -56,7 +59,8 @@ public void LeftOuterJoinResults(JoinOperation op, bool passProjectors) (qux, default)); } - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public void LeftOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -70,7 +74,8 @@ public void LeftOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) result.AssertCollectionEqual(); } - [Theory, MemberData(nameof(GetLeftOuterJoins))] + [Test] + [MethodDataSource(nameof(GetLeftOuterJoins))] public void LeftOuterJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Test/MaxItemsTest.cs b/Tests/SuperLinq.Tests/MaxItemsTest.cs similarity index 94% rename from Tests/SuperLinq.Test/MaxItemsTest.cs rename to Tests/SuperLinq.Tests/MaxItemsTest.cs index fa1763222..463a44d8b 100644 --- a/Tests/SuperLinq.Test/MaxItemsTest.cs +++ b/Tests/SuperLinq.Tests/MaxItemsTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class MaxItemsTest { - [Fact] + [Test] public void MaxItemsIsLazy() { _ = new BreakingSequence().MaxItems(); } - [Fact] + [Test] public void MaxItemsEmptyList() { using var seq = TestingSequence.Of(); @@ -16,7 +16,7 @@ public void MaxItemsEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MaxItemsBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -24,13 +24,13 @@ public void MaxItemsBehavior() result.AssertSequenceEqual(5, 5); } - [Fact] + [Test] public void MaxItemsComparerIsLazy() { _ = new BreakingSequence().MaxItems(comparer: null); } - [Fact] + [Test] public void MaxItemsComparerEmptyList() { using var seq = TestingSequence.Of(); @@ -38,7 +38,7 @@ public void MaxItemsComparerEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MaxItemsComparerBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -46,14 +46,14 @@ public void MaxItemsComparerBehavior() result.AssertSequenceEqual(2, 2, 5, 5, 2, 2); } - [Fact] + [Test] public void MaxItemsByIsLazy() { _ = new BreakingSequence().MaxItemsBy(BreakingFunc.Of()); _ = new BreakingSequence().MaxByWithTies(BreakingFunc.Of()); } - [Fact] + [Test] public void MaxItemsByEmptyList() { using var seq = TestingSequence.Of(); @@ -61,7 +61,7 @@ public void MaxItemsByEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MaxItemsByBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -69,13 +69,13 @@ public void MaxItemsByBehavior() result.AssertSequenceEqual(0, 0, 0, 0); } - [Fact] + [Test] public void MaxItemsByComparerIsLazy() { _ = new BreakingSequence().MaxByWithTies(BreakingFunc.Of(), comparer: null); } - [Fact] + [Test] public void MaxItemsByComparerEmptyList() { using var seq = TestingSequence.Of(); @@ -83,7 +83,7 @@ public void MaxItemsByComparerEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MaxItemsByComparerBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); diff --git a/Tests/SuperLinq.Test/MemoizeTest.cs b/Tests/SuperLinq.Tests/MemoizeTest.cs similarity index 95% rename from Tests/SuperLinq.Test/MemoizeTest.cs rename to Tests/SuperLinq.Tests/MemoizeTest.cs index 0a3d1e44a..3f3fd42ce 100644 --- a/Tests/SuperLinq.Test/MemoizeTest.cs +++ b/Tests/SuperLinq.Tests/MemoizeTest.cs @@ -1,22 +1,21 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; public sealed class MemoizeTest { - [Fact] + [Test] public void MemoizeIsLazy() { _ = new BreakingSequence().Memoize(); } - public static IEnumerable GetSequences() => + public static IEnumerable> GetSequences() => Enumerable.Range(1, 10) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); + .GetBreakingCollectionSequences(); - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void MemoizeSimpleUse(IDisposableEnumerable seq) { using (seq) @@ -29,8 +28,8 @@ public void MemoizeSimpleUse(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void MemoizeReturningExpectedElementsWhenUsedAtInnerForEach(IDisposableEnumerable seq) { using (seq) @@ -91,8 +90,8 @@ static IEnumerable InnerForEach(IEnumerable source) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public static void MemoizeThrowsWhenCacheDisposedDuringIteration(IDisposableEnumerable seq) { using (seq) @@ -109,8 +108,8 @@ public static void MemoizeThrowsWhenCacheDisposedDuringIteration(IDisposableEnum } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public static void MemoizeThrowsWhenResetDuringIteration(IDisposableEnumerable seq) { using (seq) @@ -128,8 +127,8 @@ public static void MemoizeThrowsWhenResetDuringIteration(IDisposableEnumerable seq) { using (seq) @@ -144,8 +143,8 @@ public static void MemoizeThrowsWhenGettingIteratorAfterDispose(IDisposableEnume } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public static void MemoizeThrowsWhenResettingAfterDispose(IDisposableEnumerable seq) { using (seq) @@ -159,7 +158,7 @@ public static void MemoizeThrowsWhenResettingAfterDispose(IDisposableEnumerable< } } - [Fact] + [Test] public void MemoizeIteratorWithPartialIterationBeforeCompleteIteration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -174,7 +173,7 @@ public void MemoizeIteratorWithPartialIterationBeforeCompleteIteration() Assert.Equal(10, buffer.Count); } - [Fact] + [Test] public void MemoizeIteratorWithDisposeOnEarlyExitTrue() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -189,7 +188,7 @@ public void MemoizeIteratorWithDisposeOnEarlyExitTrue() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public void MemoizeIteratorDisposesAfterSourceIsIteratedEntirely() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -200,7 +199,7 @@ public void MemoizeIteratorDisposesAfterSourceIsIteratedEntirely() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public void MemoizeIteratorEnumeratesOnlyOnce() { using var ts = Enumerable.Range(0, 10).AsTestingSequence(); @@ -211,7 +210,7 @@ public void MemoizeIteratorEnumeratesOnlyOnce() buffer.AssertSequenceEqual(Enumerable.Range(0, 10)); } - [Fact] + [Test] public static void MemoizeIteratorRestartsAfterReset() { var starts = 0; @@ -234,7 +233,7 @@ IEnumerable TestSequence() Assert.Equal(2, starts); } - [Fact] + [Test] public void MemoizeIteratorRethrowsErrorDuringIterationToAllIteratorsUntilReset() { using var xs = SeqExceptionAt(2).AsTestingSequence(maxEnumerations: 2); @@ -257,7 +256,7 @@ public void MemoizeIteratorRethrowsErrorDuringIterationToAllIteratorsUntilReset( Assert.Equal(1, r1.Read()); } - [Fact] + [Test] public void MemoizeIteratorRethrowsErrorDuringIterationStartToAllIteratorsUntilReset() { var i = 0; @@ -287,7 +286,7 @@ public void MemoizeIteratorRethrowsErrorDuringIterationStartToAllIteratorsUntilR Assert.Equal(1, buffer.Count); } - [Fact] + [Test] public void MemoizeIteratorRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { using var seq = new FailingEnumerable().AsTestingSequence(maxEnumerations: 2); @@ -320,7 +319,7 @@ public IEnumerator GetEnumerator() IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } - [Fact] + [Test] public void MemoizeCollectionsUseCopyTo() { using var list = new BreakingCollection(Enumerable.Range(0, 10)); @@ -332,7 +331,7 @@ public void MemoizeCollectionsUseCopyTo() Assert.Equal(10, buffer.Count); } - [Fact] + [Test] public void MemoizeCollectionEnumeratesOnlyOnce() { using var ts = new BreakingCollection(Enumerable.Range(0, 10)); @@ -346,7 +345,7 @@ public void MemoizeCollectionEnumeratesOnlyOnce() Assert.Equal(10, buffer.Count); } - [Fact] + [Test] public static void MemoizeCollectionRestartsAfterReset() { using var ts = new BreakingCollection(Enumerable.Range(0, 10)); @@ -364,7 +363,7 @@ public static void MemoizeCollectionRestartsAfterReset() Assert.Equal(10, memoized.Count); } - [Fact] + [Test] public void MemoizeCollectionRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { using var ts = new FailingCollection(); @@ -395,7 +394,7 @@ public override void CopyTo(int[] array, int arrayIndex) } } - [Fact] + [Test] public void MemoizeProxySimpleUse() { var ts = Enumerable.Range(1, 10).ToArray(); @@ -411,7 +410,7 @@ public void MemoizeProxySimpleUse() Assert.Equal(10, buffer.Count); } - [Fact] + [Test] public void MemoizeProxyThrowsExceptionAfterDisposal() { var ts = Enumerable.Range(1, 10).ToArray(); @@ -423,7 +422,7 @@ public void MemoizeProxyThrowsExceptionAfterDisposal() _ = Assert.Throws(buffer.Consume); } - [Fact] + [Test] public void MemoizeProxyThrowsExceptionWhenResettingAfterDisposal() { var ts = Enumerable.Range(1, 10).ToArray(); @@ -435,7 +434,7 @@ public void MemoizeProxyThrowsExceptionWhenResettingAfterDisposal() _ = Assert.Throws(buffer.Reset); } - [Fact] + [Test] public void MemoizeProxyReturnsCollectionIteratorDirectly() { var iterator = Enumerable.Empty().GetEnumerator(); diff --git a/Tests/SuperLinq.Test/MinItemsTest.cs b/Tests/SuperLinq.Tests/MinItemsTest.cs similarity index 95% rename from Tests/SuperLinq.Test/MinItemsTest.cs rename to Tests/SuperLinq.Tests/MinItemsTest.cs index e61a9388f..55a14f107 100644 --- a/Tests/SuperLinq.Test/MinItemsTest.cs +++ b/Tests/SuperLinq.Tests/MinItemsTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class MinItemsTest { - [Fact] + [Test] public void MinItemsIsLazy() { _ = new BreakingSequence().MinItems(); } - [Fact] + [Test] public void MinItemsEmptyList() { using var seq = TestingSequence.Of(); @@ -16,7 +16,7 @@ public void MinItemsEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MinItemsBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -24,13 +24,13 @@ public void MinItemsBehavior() result.AssertSequenceEqual(0, 0, 0, 0); } - [Fact] + [Test] public void MinItemsComparerIsLazy() { _ = new BreakingSequence().MinItems(comparer: null); } - [Fact] + [Test] public void MinItemsComparerEmptyList() { using var seq = TestingSequence.Of(); @@ -38,7 +38,7 @@ public void MinItemsComparerEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MinItemsComparerBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -46,14 +46,14 @@ public void MinItemsComparerBehavior() result.AssertSequenceEqual(0, 0, 3, 3, 0, 3, 3, 0); } - [Fact] + [Test] public void MinItemsByIsLazy() { _ = new BreakingSequence().MinItemsBy(BreakingFunc.Of()); _ = new BreakingSequence().MinByWithTies(BreakingFunc.Of()); } - [Fact] + [Test] public void MinItemsByEmptyList() { using var seq = TestingSequence.Of(); @@ -61,7 +61,7 @@ public void MinItemsByEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MinItemsByBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); @@ -69,14 +69,14 @@ public void MinItemsByBehavior() result.AssertSequenceEqual(5, 5); } - [Fact] + [Test] public void MinItemsByComparerIsLazy() { _ = new BreakingSequence().MinItemsBy(BreakingFunc.Of(), comparer: null); _ = new BreakingSequence().MinByWithTies(BreakingFunc.Of(), comparer: null); } - [Fact] + [Test] public void MinItemsByComparerEmptyList() { using var seq = TestingSequence.Of(); @@ -84,7 +84,7 @@ public void MinItemsByComparerEmptyList() result.AssertSequenceEqual(); } - [Fact] + [Test] public void MinItemsByComparerBehavior() { using var seq = TestingSequence.Of(2, 2, 0, 5, 5, 1, 1, 0, 3, 4, 2, 3, 1, 4, 0, 2, 4, 3, 3, 0); diff --git a/Tests/SuperLinq.Test/MoveTest.cs b/Tests/SuperLinq.Tests/MoveTest.cs similarity index 77% rename from Tests/SuperLinq.Test/MoveTest.cs rename to Tests/SuperLinq.Tests/MoveTest.cs index d4b634843..a9e59ec02 100644 --- a/Tests/SuperLinq.Test/MoveTest.cs +++ b/Tests/SuperLinq.Tests/MoveTest.cs @@ -1,35 +1,36 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class MoveTest { - [Fact] + [Test] public void MoveWithNegativeFromIndex() { _ = Assert.Throws(() => new[] { 1 }.Move(-1, 0, 0)); } - [Fact] + [Test] public void MoveWithNegativeCount() { _ = Assert.Throws(() => new[] { 1 }.Move(0, -1, 0)); } - [Fact] + [Test] public void MoveWithNegativeToIndex() { _ = Assert.Throws(() => new[] { 1 }.Move(0, 0, -1)); } - [Fact] + [Test] public void MoveIsLazy() { _ = new BreakingSequence().Move(0, 0, 0); } - [Theory, MemberData(nameof(MoveSource))] + [Test] + [MethodDataSource(nameof(MoveSource))] public void Move(int length, int fromIndex, int count, int toIndex) { var source = Enumerable.Range(0, length); @@ -44,21 +45,22 @@ public void Move(int length, int fromIndex, int count, int toIndex) result.AssertSequenceEqual(expectations); } - public static IEnumerable MoveSource() + public static IEnumerable<(int length, int fromIndex, int count, int toIndex)> MoveSource() { const int Length = 10; return from index in Enumerable.Range(0, Length) from count in Enumerable.Range(0, Length + 1) - from tcd in new object[][] + from tcd in new (int length, int fromIndex, int count, int toIndex)[] { - [Length, index, count, Math.Max(0, index - 1),], - [Length, index, count, index + 1,], + (Length, index, count, Math.Max(0, index - 1)), + (Length, index, count, index + 1), } select tcd; } - [Theory, MemberData(nameof(MoveWithSequenceShorterThanToIndexSource))] + [Test] + [MethodDataSource(nameof(MoveWithSequenceShorterThanToIndexSource))] public void MoveWithSequenceShorterThanToIndex(int length, int fromIndex, int count, int toIndex) { var source = Enumerable.Range(0, length); @@ -73,11 +75,11 @@ public void MoveWithSequenceShorterThanToIndex(int length, int fromIndex, int co Assert.Equal(expectations, result); } - public static IEnumerable MoveWithSequenceShorterThanToIndexSource() => + public static IEnumerable<(int length, int fromIndex, int count, int toIndex)> MoveWithSequenceShorterThanToIndexSource() => Enumerable.Range(10, 10 + 5) - .Select(toIndex => new object[] { 10, 5, 2, toIndex }); + .Select(toIndex => (10, 5, 2, toIndex)); - [Fact] + [Test] public void MoveIsRepeatable() { using var source = Enumerable.Range(0, 10).AsTestingSequence(maxEnumerations: 2); @@ -86,7 +88,7 @@ public void MoveIsRepeatable() Assert.Equal(result, result.ToArray()); } - [Fact] + [Test] public void MoveWithFromIndexEqualsToIndex() { using var source = Enumerable.Range(0, 10).AsTestingSequence(); @@ -95,7 +97,7 @@ public void MoveWithFromIndexEqualsToIndex() result.AssertSequenceEqual(Enumerable.Range(0, 10)); } - [Fact] + [Test] public void MoveWithCountEqualsZero() { using var source = Enumerable.Range(0, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/NullArgumentTest.cs b/Tests/SuperLinq.Tests/NullArgumentTest.cs similarity index 87% rename from Tests/SuperLinq.Test/NullArgumentTest.cs rename to Tests/SuperLinq.Tests/NullArgumentTest.cs index 32104a58c..712063721 100644 --- a/Tests/SuperLinq.Test/NullArgumentTest.cs +++ b/Tests/SuperLinq.Tests/NullArgumentTest.cs @@ -7,20 +7,22 @@ using System.Reflection; using Debug = System.Diagnostics.Debug; -namespace Test; +namespace SuperLinq.Tests; public sealed class NullArgumentTest { - [Theory, MemberData(nameof(GetNotNullInlineDatas))] - public void NotNull(Action inlineData) => - inlineData(); - - [Theory, MemberData(nameof(GetCanBeNullInlineDatas))] - public void CanBeNull(Action inlineData) => - inlineData(); - - public static IEnumerable GetNotNullInlineDatas() => - GetInlineDatas(canBeNull: false, inlineDataFactory: (method, args, paramName) => () => + [Test] + [MethodDataSource(nameof(GetNotNullArguments))] + public void NotNull(Action arguments) => + arguments(); + + [Test] + [MethodDataSource(nameof(GetCanBeNullArguments))] + public void CanBeNull(Action arguments) => + arguments(); + + public static IEnumerable GetNotNullArguments() => + GetArguments(canBeNull: false, argumentsFactory: (method, args, paramName) => () => { var tie = Assert.Throws(() => method.Invoke(null, args)); @@ -32,8 +34,8 @@ public static IEnumerable GetNotNullInlineDatas() => Assert.Equal(paramName, ane.ParamName); }); - public static IEnumerable GetCanBeNullInlineDatas() => - GetInlineDatas(canBeNull: true, inlineDataFactory: (method, args, paramName) => () => + public static IEnumerable GetCanBeNullArguments() => + GetArguments(canBeNull: true, argumentsFactory: (method, args, paramName) => () => { try { @@ -41,8 +43,9 @@ public static IEnumerable GetCanBeNullInlineDatas() => } catch (TargetInvocationException tie) { - Assert.False(tie.InnerException is not null && tie.InnerException is ArgumentNullException ane - && ane.ParamName != paramName); + Assert.False( + tie.InnerException is ArgumentNullException ane + && !string.Equals(ane.ParamName, paramName, StringComparison.Ordinal)); } }); @@ -51,13 +54,13 @@ public static IEnumerable GetCanBeNullInlineDatas() => nameof(SuperEnumerable.CopyTo), ]; - private static IEnumerable GetInlineDatas(bool canBeNull, Func inlineDataFactory) => + private static IEnumerable GetArguments(bool canBeNull, Func argumentsFactory) => from m in typeof(SuperEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly) where !s_skipMethods.Contains(m.Name, StringComparer.Ordinal) - from t in CreateInlineDatas(m, canBeNull, inlineDataFactory) + from t in CreateArguments(m, canBeNull, argumentsFactory) select t; - private static IEnumerable CreateInlineDatas(MethodInfo methodDefinition, bool canBeNull, Func inlineDataFactory) + private static IEnumerable CreateArguments(MethodInfo methodDefinition, bool canBeNull, Func argumentsFactory) { var method = InstantiateMethod(methodDefinition); var parameters = method.GetParameters().ToList(); @@ -65,9 +68,7 @@ private static IEnumerable CreateInlineDatas(MethodInfo methodDefiniti return from param in parameters where IsReferenceType(param) && ParameterCanBeNull(param) == canBeNull let arguments = parameters.Select(p => p == param ? null : CreateInstance(p.ParameterType)).ToArray() - let InlineData = inlineDataFactory(method, arguments, param.Name!) - let testName = GetTestName(methodDefinition, param) - select new object[] { InlineData }; + select argumentsFactory(method, arguments, param.Name!); } private static string GetTestName(MethodInfo definition, ParameterInfo parameter) => diff --git a/Tests/SuperLinq.Test/OnErrorResumeNextTest.cs b/Tests/SuperLinq.Tests/OnErrorResumeNextTest.cs similarity index 93% rename from Tests/SuperLinq.Test/OnErrorResumeNextTest.cs rename to Tests/SuperLinq.Tests/OnErrorResumeNextTest.cs index a71f9e3fa..41df37a77 100644 --- a/Tests/SuperLinq.Test/OnErrorResumeNextTest.cs +++ b/Tests/SuperLinq.Tests/OnErrorResumeNextTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class OnErrorResumeNextTest { - [Fact] + [Test] public void OnErrorResumeNextIsLazy() { _ = new BreakingSequence().OnErrorResumeNext(new BreakingSequence()); @@ -10,7 +10,7 @@ public void OnErrorResumeNextIsLazy() _ = new BreakingSequence>().OnErrorResumeNext(); } - [Fact] + [Test] public void OnErrorResumeNextMultipleSequencesNoExceptions() { using var ts1 = Enumerable.Range(1, 10).AsTestingSequence(); @@ -28,12 +28,12 @@ public void OnErrorResumeNextMultipleSequencesNoExceptions() .Concat(Enumerable.Range(1, 10))); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - [InlineData(4)] - [InlineData(5)] + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + [Arguments(4)] + [Arguments(5)] public void OnErrorResumeNextMultipleSequencesWithNoExceptionOnSequence(int sequenceNumber) { var cnt = 1; diff --git a/Tests/SuperLinq.Test/OrderByTest.cs b/Tests/SuperLinq.Tests/OrderByTest.cs similarity index 98% rename from Tests/SuperLinq.Test/OrderByTest.cs rename to Tests/SuperLinq.Tests/OrderByTest.cs index dcba067db..1aa7dc52b 100644 --- a/Tests/SuperLinq.Test/OrderByTest.cs +++ b/Tests/SuperLinq.Tests/OrderByTest.cs @@ -1,6 +1,6 @@ using System.Globalization; -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the OrderBy/ThenBy operators @@ -10,7 +10,7 @@ public sealed class OrderByTests /// /// Verify that OrderBy preserves the selector /// - [Fact] + [Test] public void TestOrderBySelectorPreserved() { var sequenceAscending = Enumerable.Range(1, 100); @@ -30,7 +30,7 @@ public void TestOrderBySelectorPreserved() /// /// Verify that OrderBy preserves the comparer /// - [Fact] + [Test] public void TestOrderByComparerPreserved() { var sequence = Enumerable.Range(1, 100); @@ -60,7 +60,7 @@ public void TestOrderByComparerPreserved() /// /// Verify that ThenBy preserves the selector /// - [Fact] + [Test] public void TestThenBySelectorPreserved() { var sequence = new[] @@ -99,7 +99,7 @@ public void TestThenBySelectorPreserved() /// /// Verify that ThenBy preserves the comparer /// - [Fact] + [Test] public void TestThenByComparerPreserved() { var sequence = new[] diff --git a/Tests/SuperLinq.Test/PadStartTest.cs b/Tests/SuperLinq.Tests/PadStartTest.cs similarity index 85% rename from Tests/SuperLinq.Test/PadStartTest.cs rename to Tests/SuperLinq.Tests/PadStartTest.cs index a3f5925b4..1b72cb0b5 100644 --- a/Tests/SuperLinq.Test/PadStartTest.cs +++ b/Tests/SuperLinq.Tests/PadStartTest.cs @@ -1,15 +1,15 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class PadStartTest { - [Fact] + [Test] public void PadStartNegativeWidth() { _ = Assert.Throws(() => new BreakingSequence().PadStart(-1)); } - [Fact] + [Test] public void PadStartIsLazy() { _ = new BreakingSequence().PadStart(0); @@ -17,13 +17,12 @@ public void PadStartIsLazy() _ = new BreakingSequence().PadStart(0, BreakingFunc.Of()); } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Seq(123, 456, 789) - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadStartWideSourceSequence(IDisposableEnumerable seq) { using (seq) @@ -35,7 +34,7 @@ public void PadStartWideSourceSequence(IDisposableEnumerable seq) } } - [Fact] + [Test] public void PadStartWideCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -44,7 +43,7 @@ public void PadStartWideCollectionBehavior() result.AssertCollectionErrorChecking(10_000); } - [Fact] + [Test] public void PadStartWideListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -59,8 +58,8 @@ public void PadStartWideListBehavior() #endif } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadStartEqualSourceSequence(IDisposableEnumerable seq) { using (seq) @@ -72,8 +71,8 @@ public void PadStartEqualSourceSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadStartNarrowSourceSequenceWithDefaultPadding(IDisposableEnumerable seq) { using (seq) @@ -85,8 +84,8 @@ public void PadStartNarrowSourceSequenceWithDefaultPadding(IDisposableEnumerable } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadStartNarrowSourceSequenceWithNonDefaultPadding(IDisposableEnumerable seq) { using (seq) @@ -98,7 +97,7 @@ public void PadStartNarrowSourceSequenceWithNonDefaultPadding(IDisposableEnumera } } - [Fact] + [Test] public void PadStartNarrowCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -107,7 +106,7 @@ public void PadStartNarrowCollectionBehavior() result.AssertCollectionErrorChecking(40_000); } - [Fact] + [Test] public void PadStartNarrowListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -123,13 +122,12 @@ public void PadStartNarrowListBehavior() #endif } - public static IEnumerable GetCharSequences() => + public static IEnumerable> GetCharSequences() => "hello".AsEnumerable() - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetCharSequences))] + [Test] + [MethodDataSource(nameof(GetCharSequences))] public void PadStartNarrowSourceSequenceWithDynamicPadding(IDisposableEnumerable seq) { using (seq) @@ -141,7 +139,7 @@ public void PadStartNarrowSourceSequenceWithDynamicPadding(IDisposableEnumerable } } - [Fact] + [Test] public void PadStartUsesCollectionCountAtIterationTime() { var queue = new Queue(Enumerable.Range(1, 3)); diff --git a/Tests/SuperLinq.Test/PadTest.cs b/Tests/SuperLinq.Tests/PadTest.cs similarity index 80% rename from Tests/SuperLinq.Test/PadTest.cs rename to Tests/SuperLinq.Tests/PadTest.cs index 44ab4085b..fd1ffbb8b 100644 --- a/Tests/SuperLinq.Test/PadTest.cs +++ b/Tests/SuperLinq.Tests/PadTest.cs @@ -1,15 +1,17 @@ -namespace Test; +using System.Diagnostics.CodeAnalysis; + +namespace SuperLinq.Tests; public sealed class PadTest { - [Fact] + [Test] public void PadNegativeWidth() { _ = Assert.Throws(() => new BreakingSequence().Pad(-1)); } - [Fact] + [Test] public void PadIsLazy() { _ = new BreakingSequence().Pad(0); @@ -17,13 +19,12 @@ public void PadIsLazy() _ = new BreakingSequence().Pad(0, BreakingFunc.Of()); } - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Seq(123, 456, 789) - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadWideSourceSequence(IDisposableEnumerable seq) { using (seq) @@ -35,7 +36,7 @@ public void PadWideSourceSequence(IDisposableEnumerable seq) } } - [Fact] + [Test] public void PadWideCollectionBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingCollection(); @@ -44,7 +45,7 @@ public void PadWideCollectionBehavior() result.AssertCollectionErrorChecking(10_000); } - [Fact] + [Test] public void PadWideListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -59,8 +60,8 @@ public void PadWideListBehavior() #endif } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadEqualSourceSequence(IDisposableEnumerable seq) { using (seq) @@ -72,8 +73,8 @@ public void PadEqualSourceSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadNarrowSourceSequenceWithDefaultPadding(IDisposableEnumerable seq) { using (seq) @@ -85,8 +86,8 @@ public void PadNarrowSourceSequenceWithDefaultPadding(IDisposableEnumerable } } - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void PadNarrowSourceSequenceWithNonDefaultPadding(IDisposableEnumerable seq) { using (seq) @@ -98,7 +99,7 @@ public void PadNarrowSourceSequenceWithNonDefaultPadding(IDisposableEnumerable GetCharSequences() => + public static IEnumerable> GetCharSequences() => "hello".AsEnumerable() - .GetAllSequences() - .Select(x => new object[] { x }); + .GetAllSequences(); - [Theory] - [MemberData(nameof(GetCharSequences))] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(TestExtensions.GetAllSequences), Arguments = ["hello"])] + [SuppressMessage("Usage", "TUnit0001:Invalid Data for Tests")] public void PadNarrowSourceSequenceWithDynamicPadding(IDisposableEnumerable seq) { using (seq) diff --git a/Tests/SuperLinq.Test/PartialSortByTest.cs b/Tests/SuperLinq.Tests/PartialSortByTest.cs similarity index 96% rename from Tests/SuperLinq.Test/PartialSortByTest.cs rename to Tests/SuperLinq.Tests/PartialSortByTest.cs index e4542c6a0..40913f4df 100644 --- a/Tests/SuperLinq.Test/PartialSortByTest.cs +++ b/Tests/SuperLinq.Tests/PartialSortByTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class PartialSortByTests { - [Fact] + [Test] public void PartialSortBy() { var ns = SuperEnumerable.RandomDouble() @@ -16,7 +16,7 @@ public void PartialSortBy() .AssertSequenceEqual(ns.Take(5)); } - [Fact] + [Test] public void PartialSortWithOrder() { var ns = SuperEnumerable.RandomDouble() @@ -35,7 +35,7 @@ public void PartialSortWithOrder() .AssertSequenceEqual(ns.Reverse().Take(5)); } - [Fact] + [Test] public void PartialSortWithComparer() { using var alphabet = Enumerable.Range(0, 26) @@ -49,13 +49,13 @@ public void PartialSortWithComparer() .AssertSequenceEqual('A', 'C', 'E', 'G', 'I'); } - [Fact] + [Test] public void PartialSortByIsLazy() { _ = new BreakingSequence().PartialSortBy(1, BreakingFunc.Of()); } - [Fact] + [Test] public void PartialSortByIsStable() { using var list = new[] diff --git a/Tests/SuperLinq.Test/PartialSortTest.cs b/Tests/SuperLinq.Tests/PartialSortTest.cs similarity index 96% rename from Tests/SuperLinq.Test/PartialSortTest.cs rename to Tests/SuperLinq.Tests/PartialSortTest.cs index 6de80f590..070745772 100644 --- a/Tests/SuperLinq.Test/PartialSortTest.cs +++ b/Tests/SuperLinq.Tests/PartialSortTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class PartialSortTests { - [Fact] + [Test] public void PartialSort() { using var sequence = Enumerable.Range(1, 10) @@ -15,7 +15,7 @@ public void PartialSort() .AssertSequenceEqual(Enumerable.Range(0, 5)); } - [Fact] + [Test] public void PartialSortWithOrder() { using var sequence = Enumerable.Range(1, 10) @@ -31,7 +31,7 @@ public void PartialSortWithOrder() .AssertSequenceEqual(Enumerable.Range(6, 5).Reverse()); } - [Fact] + [Test] public void PartialSortWithDuplicates() { using var sequence = Enumerable.Range(1, 10) @@ -44,7 +44,7 @@ public void PartialSortWithDuplicates() .AssertSequenceEqual(1, 2, 3, 3, 3); } - [Fact] + [Test] public void PartialSortWithComparer() { using var sequence = Enumerable.Range(0, 26) @@ -57,13 +57,13 @@ public void PartialSortWithComparer() .AssertSequenceEqual('A', 'C', 'E', 'G', 'I'); } - [Fact] + [Test] public void PartialSortIsLazy() { _ = new BreakingSequence().PartialSort(1); } - [Fact] + [Test] public void PartialSortIsStable() { using var list = new[] diff --git a/Tests/SuperLinq.Test/PartitionTest.cs b/Tests/SuperLinq.Tests/PartitionTest.cs similarity index 93% rename from Tests/SuperLinq.Test/PartitionTest.cs rename to Tests/SuperLinq.Tests/PartitionTest.cs index 9d03938e0..5dcd49516 100644 --- a/Tests/SuperLinq.Test/PartitionTest.cs +++ b/Tests/SuperLinq.Tests/PartitionTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class PartitionTest { - [Fact] + [Test] public void Partition() { using var sequence = Enumerable.Range(0, 10).AsTestingSequence(); @@ -13,7 +13,7 @@ public void Partition() odds.AssertSequenceEqual(1, 3, 5, 7, 9); } - [Fact] + [Test] public void PartitionWithEmptySequence() { using var sequence = Enumerable.Empty().AsTestingSequence(); @@ -24,7 +24,7 @@ public void PartitionWithEmptySequence() odds.AssertSequenceEqual(); } - [Fact] + [Test] public void PartitionWithResultSelector() { using var sequence = Enumerable.Range(0, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/PermutationsTest.cs b/Tests/SuperLinq.Tests/PermutationsTest.cs similarity index 95% rename from Tests/SuperLinq.Test/PermutationsTest.cs rename to Tests/SuperLinq.Tests/PermutationsTest.cs index 1c1669fe4..4c530bb56 100644 --- a/Tests/SuperLinq.Test/PermutationsTest.cs +++ b/Tests/SuperLinq.Tests/PermutationsTest.cs @@ -1,6 +1,6 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; /// /// Tests that verify the behavior of the Permutations() operator. @@ -10,7 +10,7 @@ public sealed class PermutationsTest /// /// Verify that the permutation of the empty set is the empty set. /// - [Fact] + [Test] public void TestCardinalityZeroPermutation() { using var emptySet = TestingSequence.Of(); @@ -21,13 +21,12 @@ public void TestCardinalityZeroPermutation() permutations.Single().AssertSequenceEqual(); } - public static IEnumerable GetTooLongSequences() => + public static IEnumerable> GetTooLongSequences() => Enumerable.Range(1, 22) - .GetBreakingCollectionSequences() - .Select(x => new object[] { x }); + .GetBreakingCollectionSequences(); - [Theory] - [MemberData(nameof(GetTooLongSequences))] + [Test] + [MethodDataSource(nameof(GetTooLongSequences))] public void TestExceptionWhenTooLong(IDisposableEnumerable seq) { using (seq) @@ -53,7 +52,7 @@ Input set is too large to permute properly. /// /// Verify that there is one permutation of a set of one item /// - [Fact] + [Test] public void TestCardinalityOnePermutation() { using var set = TestingSequence.Of(42); @@ -68,7 +67,7 @@ public void TestCardinalityOnePermutation() /// Verify that there are two permutations of a set of two items /// and confirm that the permutations are correct. /// - [Fact] + [Test] public void TestCardinalityTwoPermutation() { using var set = TestingSequence.Of(42, 37); @@ -85,7 +84,7 @@ public void TestCardinalityTwoPermutation() /// Verify that there are six (3!) permutations of a set of three items /// and confirm the permutations are correct. /// - [Fact] + [Test] public void TestCardinalityThreePermutation() { using var set = TestingSequence.Of(42, 11, 100); @@ -113,7 +112,7 @@ public void TestCardinalityThreePermutation() /// Verify there are 24 (4!) permutations of a set of four items /// and confirm the permutations are correct. /// - [Fact] + [Test] public void TestCardinalityFourPermutation() { using var set = TestingSequence.Of(42, 11, 100, 89); @@ -158,7 +157,7 @@ public void TestCardinalityFourPermutation() /// Verify that the number of expected permutations of sets of size 5 through 10 /// are equal to the factorial of the set size. /// - [Fact] + [Test] public void TestHigherCardinalityPermutations() { // NOTE: Testing higher cardinality permutations by exhaustive comparison becomes tedious @@ -187,7 +186,7 @@ public void TestHigherCardinalityPermutations() /// Verify that the Permutations() extension does not begin evaluation until the /// resulting sequence is iterated. /// - [Fact] + [Test] public void TestPermutationsIsLazy() { _ = new BreakingSequence().Permutations(); @@ -197,7 +196,7 @@ public void TestPermutationsIsLazy() /// Verify that each permutation produced is a new object, this ensures that callers /// can request permutations and cache or store them without them being overwritten. /// - [Fact] + [Test] public void TestPermutationsAreIndependent() { using var set = Enumerable.Range(1, 4).Select(i => i * 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/PreScanTest.cs b/Tests/SuperLinq.Tests/PreScanTest.cs similarity index 94% rename from Tests/SuperLinq.Test/PreScanTest.cs rename to Tests/SuperLinq.Tests/PreScanTest.cs index 618d493b8..b9ee18260 100644 --- a/Tests/SuperLinq.Test/PreScanTest.cs +++ b/Tests/SuperLinq.Tests/PreScanTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class PreScanTest { - [Fact] + [Test] public void PreScanIsLazy() { _ = new BreakingSequence().PreScan(BreakingFunc.Of(), 0); } - [Fact] + [Test] public void PreScanWithEmptySequence() { using var source = TestingSequence.Of(); @@ -17,7 +17,7 @@ public void PreScanWithEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void PreScanWithSingleElement() { using var source = TestingSequence.Of(111); @@ -26,7 +26,7 @@ public void PreScanWithSingleElement() result.AssertSequenceEqual(999); } - [Fact] + [Test] public void PreScanSum() { using var source = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -35,7 +35,7 @@ public void PreScanSum() result.AssertSequenceEqual(0, 1, 3, 6, 10, 15, 21, 28, 36, 45); } - [Fact] + [Test] public void PreScanMul() { using var source = TestingSequence.Of(1, 2, 3); @@ -44,7 +44,7 @@ public void PreScanMul() result.AssertSequenceEqual(1, 1, 2); } - [Fact] + [Test] public void PreScanFuncIsNotInvokedUnnecessarily() { using var source = Enumerable.Range(1, 3).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/PublishTest.cs b/Tests/SuperLinq.Tests/PublishTest.cs similarity index 97% rename from Tests/SuperLinq.Test/PublishTest.cs rename to Tests/SuperLinq.Tests/PublishTest.cs index be06d215d..c0025a3ee 100644 --- a/Tests/SuperLinq.Test/PublishTest.cs +++ b/Tests/SuperLinq.Tests/PublishTest.cs @@ -1,16 +1,16 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; public sealed class PublishTest { - [Fact] + [Test] public void PublishIsLazy() { _ = new BreakingSequence().Publish(); } - [Fact] + [Test] public void PublishWithSingleConsumer() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -19,7 +19,7 @@ public void PublishWithSingleConsumer() result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public void PublishWithMultipleConsumers() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -69,7 +69,7 @@ public void PublishWithMultipleConsumers() Assert.Equal(0, result.Count); } - [Fact] + [Test] public void PublishWithInnerConsumer() { using var seq = Enumerable.Range(1, 6).AsTestingSequence(); @@ -96,7 +96,7 @@ public void PublishWithInnerConsumer() Assert.Equal(0, result.Count); } - [Fact] + [Test] public void PublishWithSequentialPartialConsumers() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -129,7 +129,7 @@ public void PublishWithSequentialPartialConsumers() Assert.Equal(0, result.Count); } - [Fact] + [Test] public void PublishDisposesAfterSourceIsIteratedEntirely() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -140,7 +140,7 @@ public void PublishDisposesAfterSourceIsIteratedEntirely() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public void PublishDisposesWithPartialEnumeration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -153,7 +153,7 @@ public void PublishDisposesWithPartialEnumeration() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public void PublishRestartsAfterReset() { var starts = 0; @@ -176,7 +176,7 @@ IEnumerable TestSequence() Assert.Equal(2, starts); } - [Fact] + [Test] public void PublishThrowsWhenCacheDisposedDuringIteration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -191,7 +191,7 @@ public void PublishThrowsWhenCacheDisposedDuringIteration() () => reader.Read()); } - [Fact] + [Test] public void PublishThrowsWhenResetDuringIteration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -207,7 +207,7 @@ public void PublishThrowsWhenResetDuringIteration() Assert.Equal("Buffer reset during iteration.", ex.Message); } - [Fact] + [Test] public void PublishThrowsWhenGettingIteratorAfterDispose() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -219,7 +219,7 @@ public void PublishThrowsWhenGettingIteratorAfterDispose() buffer.Consume); } - [Fact] + [Test] public void PublishThrowsWhenResettingAfterDispose() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -231,7 +231,7 @@ public void PublishThrowsWhenResettingAfterDispose() buffer.Reset); } - [Fact] + [Test] public void PublishRethrowsErrorDuringIterationToAllIteratorsUntilReset() { using var xs = SeqExceptionAt(2).AsTestingSequence(maxEnumerations: 2); @@ -258,7 +258,7 @@ public void PublishRethrowsErrorDuringIterationToAllIteratorsUntilReset() Assert.Equal(1, r4.Read()); } - [Fact] + [Test] public void PublishRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { using var seq = new FailingEnumerable().AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Test/RandomSubsetTest.cs b/Tests/SuperLinq.Tests/RandomSubsetTest.cs similarity index 95% rename from Tests/SuperLinq.Test/RandomSubsetTest.cs rename to Tests/SuperLinq.Tests/RandomSubsetTest.cs index 425040025..15f688970 100644 --- a/Tests/SuperLinq.Test/RandomSubsetTest.cs +++ b/Tests/SuperLinq.Tests/RandomSubsetTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Tests that verify the behavior of the RandomSubset() operator @@ -8,7 +8,7 @@ public sealed class RandomSubsetTest /// /// Verify that RandomSubset() behaves in a lazy manner. /// - [Fact] + [Test] public void TestRandomSubsetIsLazy() { _ = new BreakingSequence().RandomSubset(10); @@ -18,7 +18,7 @@ public void TestRandomSubsetIsLazy() /// /// Verify that involving RandomSubsets with a subset size less than 0 results in an exception. /// - [Fact] + [Test] public void TestRandomSubsetNegativeSubsetSize() { _ = Assert.Throws(() => @@ -28,7 +28,7 @@ public void TestRandomSubsetNegativeSubsetSize() /// /// Verify that involving RandomSubsets with a subset size less than 0 results in an exception. /// - [Fact] + [Test] public void TestRandomSubsetNegativeSubsetSize2() { _ = Assert.Throws(() => @@ -38,7 +38,7 @@ public void TestRandomSubsetNegativeSubsetSize2() /// /// Verify that the 0-size random subset of the empty set is the empty set. /// - [Fact] + [Test] public void TestRandomSubsetOfEmptySequence() { using var sequence = TestingSequence.Of(); @@ -50,7 +50,7 @@ public void TestRandomSubsetOfEmptySequence() /// /// Verify that RandomSubset can produce a random subset of equal length to the original sequence. /// - [Fact] + [Test] public void TestRandomSubsetSameLengthAsSequence() { using var sequence = Enumerable.Range(1, 100).AsTestingSequence(maxEnumerations: 2); @@ -65,7 +65,7 @@ public void TestRandomSubsetSameLengthAsSequence() /// /// Verify that RandomSubset can produce a random subset shorter than the original sequence. /// - [Fact] + [Test] public void TestRandomSubsetShorterThanSequence() { using var sequence = Enumerable.Range(1, 100).AsTestingSequence(maxEnumerations: 2); @@ -81,7 +81,7 @@ public void TestRandomSubsetShorterThanSequence() /// Verify that attempting to fetch a random subset longer than the original sequence /// results in an exception. Only thrown when the resulting random sequence is enumerated. /// - [Fact] + [Test] public void TestRandomSubsetLongerThanSequence() { using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -94,7 +94,7 @@ public void TestRandomSubsetLongerThanSequence() /// Verify that attempting to fetch a random subset longer than the original sequence /// results in an exception. Only thrown when the resulting random sequence is enumerated. /// - [Fact] + [Test] public void TestRandomSubsetLongerThanSequence2() { using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); @@ -125,12 +125,12 @@ public void TestRandomSubsetLongerThanSequence2() /// approaching unity (1.0). Which, given that the original sequence was monotonic, implies /// there cannot be a selection bias in the returned subsets - quod erat demonstrandum (QED). /// - [Fact(Skip = "Explicit")] + [Test] public void TestRandomSubsetIsUnbiased() { - using var sequence = Enumerable.Range(1, 20).AsTestingSequence(); + var sequence = Enumerable.Range(1, 20).ToArray(); - var rsdTrials = new[] { 1000, 10000, 100000, 500000, 10000000 }; + var rsdTrials = new[] { 1000, 10000, 100000, 1000000 }; var rsdResults = new[] { 0.0, 0.0, 0.0, 0.0, 0.0 }; var trialIndex = 0; @@ -158,8 +158,8 @@ public void TestRandomSubsetIsUnbiased() // for sanity, we output the RSD% values as a cross-check, the expected result should be // that the RSD% rapidly decreases and eventually drops below 1.0 - Console.WriteLine("RSD% = {0:0.00000}, {1:0.00000}, {2:0.00000}, {3:0.00000}, {4:0.00000}", - rsdResults[0], rsdResults[1], rsdResults[2], rsdResults[3], rsdResults[4]); + Console.WriteLine("RSD% = {0:0.00000}, {1:0.00000}, {2:0.00000}, {3:0.00000}", + rsdResults[0], rsdResults[1], rsdResults[2], rsdResults[3]); } /// @@ -170,7 +170,7 @@ public void TestRandomSubsetIsUnbiased() /// This attempts to verify that the original sequence remains unaltered after a random /// subset is returned and enumerated. /// - [Fact] + [Test] public void TestRandomSubsetIsIdempotent() { var sequence = Enumerable.Range(1, 100).ToArray(); @@ -186,7 +186,7 @@ public void TestRandomSubsetIsIdempotent() /// /// Verify that RandomSubset produces subset where all elements belongs to original sequence. /// - [Fact] + [Test] public void TestRandomSubsetReturnsOriginalSequenceElements() { using var sequence = Enumerable.Range(1, 100).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/RandomTest.cs b/Tests/SuperLinq.Tests/RandomTest.cs similarity index 97% rename from Tests/SuperLinq.Test/RandomTest.cs rename to Tests/SuperLinq.Tests/RandomTest.cs index f5f524626..cedbec73f 100644 --- a/Tests/SuperLinq.Test/RandomTest.cs +++ b/Tests/SuperLinq.Tests/RandomTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Tests of the various overloads of .Random() @@ -10,7 +10,7 @@ public sealed class RandomTest /// /// Verify that passing a negative maximum value yields an exception /// - [Fact] + [Test] public void TestNegativeMaxValueException() { _ = Assert.Throws(() => @@ -21,7 +21,7 @@ public void TestNegativeMaxValueException() /// Verify that passing lower bound that is greater than the upper bound results /// in an exception. /// - [Fact] + [Test] public void TestMinValueGreaterThanMaxValueException() { _ = Assert.Throws(() => @@ -31,7 +31,7 @@ public void TestMinValueGreaterThanMaxValueException() /// /// Verify that we can produce a valid sequence or random doubles between 0.0 and 1.0 /// - [Fact] + [Test] public void TestRandomDouble() { var resultA = SuperEnumerable.RandomDouble().Take(RandomTrials); @@ -47,7 +47,7 @@ public void TestRandomDouble() /// /// Verify that the max constraint is preserved by the sequence generator. /// - [Fact] + [Test] public void TestRandomMaxConstraint() { var resultA = SuperEnumerable.Random(100).Take(RandomTrials); @@ -62,7 +62,7 @@ public void TestRandomMaxConstraint() /// /// Verify that the min/max constraints are preserved by the sequence generator. /// - [Fact] + [Test] public void TestRandomMinMaxConstraint() { var resultA = SuperEnumerable.Random(0, 100).Take(RandomTrials); @@ -78,7 +78,7 @@ public void TestRandomMinMaxConstraint() /// Evaluate that using a random sequence (with a given generator) /// is equivalent to a for loop accessing the same random generator. /// - [Fact] + [Test] public void TestRandomEquivalence() { // must use a specific seed to ensure sequences will be identical diff --git a/Tests/SuperLinq.Test/RankTest.cs b/Tests/SuperLinq.Tests/RankTest.cs similarity index 82% rename from Tests/SuperLinq.Test/RankTest.cs rename to Tests/SuperLinq.Tests/RankTest.cs index ebdf80c0a..3cb6a1afb 100644 --- a/Tests/SuperLinq.Test/RankTest.cs +++ b/Tests/SuperLinq.Tests/RankTest.cs @@ -1,11 +1,11 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class RankTests { /// /// Verify that Rank uses deferred execution /// - [Fact] + [Test] public void TestRankIsLazy() { _ = new BreakingSequence().Rank(); @@ -15,24 +15,23 @@ public void TestRankIsLazy() /// /// Verify that RankBy uses deferred execution /// - [Fact] + [Test] public void TestRankByIsLazy() { _ = new BreakingSequence().RankBy(BreakingFunc.Of()); _ = new BreakingSequence().RankBy(BreakingFunc.Of(), OrderByDirection.Ascending); } - public static IEnumerable GetSimpleSequences() => + public static IEnumerable> GetSimpleSequences() => Enumerable.Repeat(1, 10) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that calling Rank with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Theory] - [MemberData(nameof(GetSimpleSequences))] + [Test] + [MethodDataSource(nameof(GetSimpleSequences))] public void TestRankNullComparer(IDisposableEnumerable seq) { var expected = Enumerable.Repeat((1, 1), 10); @@ -52,8 +51,8 @@ public void TestRankNullComparer(IDisposableEnumerable seq) /// Verify that calling RankBy with null comparer results in a sequence /// ordered using the default comparer for the given element. /// - [Theory] - [MemberData(nameof(GetSimpleSequences))] + [Test] + [MethodDataSource(nameof(GetSimpleSequences))] public void TestRankByNullComparer(IDisposableEnumerable seq) { var expected = Enumerable.Repeat((1, 1), 10); @@ -69,19 +68,18 @@ public void TestRankByNullComparer(IDisposableEnumerable seq) } } - public static IEnumerable GetDescendingIntSequences() => + public static IEnumerable> GetDescendingIntSequences() => Enumerable.Range(456, 100) .Reverse() - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that calling Rank with null comparer on a source in reverse order /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Theory] - [MemberData(nameof(GetDescendingIntSequences))] + [Test] + [MethodDataSource(nameof(GetDescendingIntSequences))] public void TestRankDescendingSequence(IDisposableEnumerable seq) { var expected = @@ -101,18 +99,17 @@ public void TestRankDescendingSequence(IDisposableEnumerable seq) } } - public static IEnumerable GetAscendingIntSequences() => + public static IEnumerable> GetAscendingIntSequences() => Enumerable.Range(456, 100) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that calling Rank with null comparer on a source in ascending order /// results in a sequence in ascending order, using the default comparer for /// the given element. /// - [Theory] - [MemberData(nameof(GetAscendingIntSequences))] + [Test] + [MethodDataSource(nameof(GetAscendingIntSequences))] public void TestRankAscendingSequence(IDisposableEnumerable seq) { var expected = @@ -137,8 +134,8 @@ public void TestRankAscendingSequence(IDisposableEnumerable seq) /// results in a sequence in descending order, using OrderByDirection.Descending /// with the default comparer for the given element. /// - [Theory] - [MemberData(nameof(GetAscendingIntSequences))] + [Test] + [MethodDataSource(nameof(GetAscendingIntSequences))] public void TestRankOrderByDescending(IDisposableEnumerable seq) { var expected = @@ -155,18 +152,17 @@ public void TestRankOrderByDescending(IDisposableEnumerable seq) } } - public static IEnumerable GetGroupedSequences() => + public static IEnumerable> GetGroupedSequences() => Enumerable.Range(0, 10) .Concat(Enumerable.Range(0, 10)) .Concat(Enumerable.Range(0, 10)) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that the rank of equivalent items in a sequence is the same. /// - [Theory] - [MemberData(nameof(GetGroupedSequences))] + [Test] + [MethodDataSource(nameof(GetGroupedSequences))] public void TestRankGroupedItems(IDisposableEnumerable seq) { var expected = @@ -192,7 +188,7 @@ public void TestRankGroupedItems(IDisposableEnumerable seq) } public sealed record Person(string Name, int Age, int ExpectedRank); - public static IEnumerable GetPersonSequences1() => + public static IEnumerable> GetPersonSequences1() => new[] { new Person(Name: "Bob", Age: 24, ExpectedRank: 4), @@ -204,10 +200,9 @@ public static IEnumerable GetPersonSequences1() => new Person(Name: "Jim", Age: 74, ExpectedRank: 8), new Person(Name: "Jes", Age: 11, ExpectedRank: 1), } - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); - public static IEnumerable GetPersonSequences2() => + public static IEnumerable> GetPersonSequences2() => new[] { new Person(Name: "Tim", Age: 23, ExpectedRank: 4), @@ -219,15 +214,14 @@ public static IEnumerable GetPersonSequences2() => new Person(Name: "Mel", Age: 28, ExpectedRank: 6), new Person(Name: "Jim", Age: 28, ExpectedRank: 6), } - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that we can rank items by an arbitrary key produced from the item. /// - [Theory] - [MemberData(nameof(GetPersonSequences1))] - [MemberData(nameof(GetPersonSequences2))] + [Test] + [MethodDataSource(nameof(GetPersonSequences1))] + [MethodDataSource(nameof(GetPersonSequences2))] public void TestRankByKeySelector(IDisposableEnumerable seq) { var expectedLength = 8; @@ -247,17 +241,16 @@ static bool HasExpectedRank(IEnumerable<(Person item, int rank)> result) => result.All(x => x.rank == x.item.ExpectedRank); } - public static IEnumerable GetDateTimeSequences() => + public static IEnumerable> GetDateTimeSequences() => Enumerable.Range(1, 10) .Select(x => new DateTime(2010, x, 20 - x)) - .GetTestingSequence(maxEnumerations: 2) - .Select(x => new object[] { x }); + .GetTestingSequence(maxEnumerations: 2); /// /// Verify that Rank can use a custom comparer /// - [Theory] - [MemberData(nameof(GetDateTimeSequences))] + [Test] + [MethodDataSource(nameof(GetDateTimeSequences))] public void TestRankCustomComparer1(IDisposableEnumerable seq) { var expected = @@ -286,8 +279,8 @@ public void TestRankCustomComparer1(IDisposableEnumerable seq) /// /// Verify that RankBy can use a custom comparer with a key selector /// - [Theory] - [MemberData(nameof(GetDateTimeSequences))] + [Test] + [MethodDataSource(nameof(GetDateTimeSequences))] public void TestRankCustomComparer2(IDisposableEnumerable seq) { var expected = diff --git a/Tests/SuperLinq.Test/ReadOnlyCollection.cs b/Tests/SuperLinq.Tests/ReadOnlyCollection.cs similarity index 94% rename from Tests/SuperLinq.Test/ReadOnlyCollection.cs rename to Tests/SuperLinq.Tests/ReadOnlyCollection.cs index 453eec86e..831ca7161 100644 --- a/Tests/SuperLinq.Test/ReadOnlyCollection.cs +++ b/Tests/SuperLinq.Tests/ReadOnlyCollection.cs @@ -1,6 +1,6 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; internal static class ReadOnlyCollection { diff --git a/Tests/SuperLinq.Test/RepeatTest.cs b/Tests/SuperLinq.Tests/RepeatTest.cs similarity index 87% rename from Tests/SuperLinq.Test/RepeatTest.cs rename to Tests/SuperLinq.Tests/RepeatTest.cs index 4ef628847..419b7100b 100644 --- a/Tests/SuperLinq.Test/RepeatTest.cs +++ b/Tests/SuperLinq.Tests/RepeatTest.cs @@ -1,11 +1,11 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class RepeatTest { - [Theory] - [InlineData(1)] - [InlineData(10)] - [InlineData(50)] + [Test] + [Arguments(1)] + [Arguments(10)] + [Arguments(50)] public void RepeatItemForeverBehavior(int repeats) { var result = SuperEnumerable.Repeat(42); @@ -16,20 +16,20 @@ public void RepeatItemForeverBehavior(int repeats) .All(x => x == 42)); } - [Fact] + [Test] public void RepeatIsLazy() { _ = new BreakingSequence().Repeat(4); } - [Fact] + [Test] public void RepeatValidatesArguments() { _ = Assert.Throws("count", () => new BreakingSequence().Repeat(0)); } - [Fact] + [Test] public void RepeatBehavior() { using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -43,16 +43,16 @@ public void RepeatBehavior() result.AssertSequenceEqual(expected); } - [Fact] + [Test] public void RepeatForeverIsLazy() { _ = new BreakingSequence().Repeat(); } - [Theory] - [InlineData(1)] - [InlineData(10)] - [InlineData(50)] + [Test] + [Arguments(1)] + [Arguments(10)] + [Arguments(50)] public void RepeatForeverBehavior(int repeats) { using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ReplaceTest.cs b/Tests/SuperLinq.Tests/ReplaceTest.cs similarity index 84% rename from Tests/SuperLinq.Test/ReplaceTest.cs rename to Tests/SuperLinq.Tests/ReplaceTest.cs index 567c805bc..8e327de90 100644 --- a/Tests/SuperLinq.Test/ReplaceTest.cs +++ b/Tests/SuperLinq.Tests/ReplaceTest.cs @@ -1,10 +1,10 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class ReplaceTest { - [Fact] + [Test] public void ReplaceIsLazy() { _ = new BreakingSequence().Replace(0, 10); @@ -12,7 +12,7 @@ public void ReplaceIsLazy() _ = new BreakingSequence().Replace(^0, 10); } - [Fact] + [Test] public void ReplaceEmptySequence() { using var seq = Enumerable.Empty().AsTestingSequence(maxEnumerations: 6); @@ -24,13 +24,14 @@ public void ReplaceEmptySequence() seq.Replace(^10, 10).AssertSequenceEqual(); } - public static IEnumerable Indices() => + public static IEnumerable<(int index, IDisposableEnumerable seq)> Indices() => Enumerable.Range(0, 10) .SelectMany( _ => Enumerable.Range(1, 10).GetAllSequences(), - (i, s) => new object[] { i, s }); + (i, s) => (i, s)); - [Theory, MemberData(nameof(Indices))] + [Test] + [MethodDataSource(nameof(Indices))] public void ReplaceIntIndex(int index, IDisposableEnumerable seq) { using (seq) @@ -44,7 +45,8 @@ public void ReplaceIntIndex(int index, IDisposableEnumerable seq) } } - [Theory, MemberData(nameof(Indices))] + [Test] + [MethodDataSource(nameof(Indices))] public void ReplaceStartIndex(int index, IDisposableEnumerable seq) { using (seq) @@ -58,7 +60,8 @@ public void ReplaceStartIndex(int index, IDisposableEnumerable seq) } } - [Theory, MemberData(nameof(Indices))] + [Test] + [MethodDataSource(nameof(Indices))] public void ReplaceEndIndex(int index, IDisposableEnumerable seq) { using (seq) @@ -73,13 +76,12 @@ public void ReplaceEndIndex(int index, IDisposableEnumerable seq) } } - public static IEnumerable GetSequences() => + public static IEnumerable> GetSequences() => Enumerable.Range(1, 10) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void ReplaceIntIndexPastSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -91,8 +93,8 @@ public void ReplaceIntIndexPastSequenceLength(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void ReplaceStartIndexPastSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -104,8 +106,8 @@ public void ReplaceStartIndexPastSequenceLength(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void ReplaceEndIndexPastSequenceLength(IDisposableEnumerable seq) { using (seq) @@ -117,7 +119,7 @@ public void ReplaceEndIndexPastSequenceLength(IDisposableEnumerable seq) } } - [Fact] + [Test] public void ReplaceListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/RetryTest.cs b/Tests/SuperLinq.Tests/RetryTest.cs similarity index 96% rename from Tests/SuperLinq.Test/RetryTest.cs rename to Tests/SuperLinq.Tests/RetryTest.cs index 563bb7aaa..aefc24d16 100644 --- a/Tests/SuperLinq.Test/RetryTest.cs +++ b/Tests/SuperLinq.Tests/RetryTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class RetryTest { - [Fact] + [Test] public void RetryIsLazy() { _ = new BreakingSequence().Retry(); } - [Fact] + [Test] public void RetryNoExceptions() { using var ts = Enumerable.Range(1, 10).AsTestingSequence(); @@ -17,7 +17,7 @@ public void RetryNoExceptions() result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public void RetryWithExceptions() { using var ts1 = SeqExceptionAt(2).AsTestingSequence(); @@ -42,13 +42,13 @@ public void RetryWithExceptions() .Concat(Enumerable.Range(1, 10))); } - [Fact] + [Test] public void RetryCountIsLazy() { _ = new BreakingSequence().Retry(3); } - [Fact] + [Test] public void RetryCountNoExceptions() { using var ts = Enumerable.Range(1, 10).AsTestingSequence(); @@ -57,7 +57,7 @@ public void RetryCountNoExceptions() result.AssertSequenceEqual(Enumerable.Range(1, 10)); } - [Fact] + [Test] public void RetryCountWithExceptionsComplete() { using var ts1 = SeqExceptionAt(2).AsTestingSequence(); @@ -82,7 +82,7 @@ public void RetryCountWithExceptionsComplete() .Concat(Enumerable.Range(1, 10))); } - [Fact] + [Test] public void RetryCountWithExceptionsThrow() { using var ts1 = SeqExceptionAt(2).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ReturnTest.cs b/Tests/SuperLinq.Tests/ReturnTest.cs similarity index 72% rename from Tests/SuperLinq.Test/ReturnTest.cs rename to Tests/SuperLinq.Tests/ReturnTest.cs index 47dc74aa4..e2f3e43d1 100644 --- a/Tests/SuperLinq.Test/ReturnTest.cs +++ b/Tests/SuperLinq.Tests/ReturnTest.cs @@ -1,4 +1,6 @@ -namespace Test; +using System.Diagnostics.CodeAnalysis; + +namespace SuperLinq.Tests; public sealed class ReturnTest { @@ -16,31 +18,31 @@ private static class NullSingleton public static IList List => (IList)s_sequence; } - [Fact] + [Test] public void TestResultingSequenceContainsSingle() { _ = Assert.Single(SomeSingleton.Sequence); } - [Fact] + [Test] public void TestResultingSequenceContainsTheItemProvided() { Assert.Contains(SomeSingleton.Item, SomeSingleton.Sequence); } - [Fact] + [Test] public void TestResultingListHasCountOne() { _ = Assert.Single(SomeSingleton.List); } - [Fact] + [Test] public void TestContainsReturnsTrueWhenTheResultingSequenceContainsTheItemProvided() { Assert.Contains(SomeSingleton.Item, SomeSingleton.Sequence); } - [Fact] + [Test] public void TestCopyToSetsTheValueAtTheIndexToTheItemContained() { var first = new object(); @@ -60,58 +62,55 @@ public void TestCopyToSetsTheValueAtTheIndexToTheItemContained() Assert.Equal(third, array[2]); } - [Fact] + [Test] public void TestResultingCollectionIsReadOnly() { Assert.True(SomeSingleton.Collection.IsReadOnly); } - [Fact] + [Test] public void TestResultingCollectionHasCountOne() { _ = Assert.Single(SomeSingleton.Collection); } - [Fact] + [Test] public void TestIndexZeroContainsTheItemProvided() { Assert.Equal(SomeSingleton.Item, SomeSingleton.List[0]); } - [Fact] + [Test] public void TestIndexOfTheItemProvidedIsZero() { Assert.Equal(0, SomeSingleton.List.IndexOf(SomeSingleton.Item)); } - [Fact] + [Test] public void TestIndexOfAnItemNotContainedIsNegativeOne() { Assert.Equal(-1, SomeSingleton.List.IndexOf(new object())); } -#pragma warning disable IDE0200 // Remove unnecessary lambda expression -#pragma warning disable IDE0300 // Collection initialization can be simplified - public static IEnumerable UnsupportedActions() => - new Action[][] - { - [() => SomeSingleton.List.Add(new object()),], - [() => SomeSingleton.Collection.Clear(),], - [() => SomeSingleton.Collection.Remove(SomeSingleton.Item),], - [() => SomeSingleton.List.RemoveAt(0),], - [() => SomeSingleton.List.Insert(0, new object()),], - [() => SomeSingleton.List[0] = new object(),], - }; -#pragma warning restore IDE0300 // Collection initialization can be simplified -#pragma warning restore IDE0200 // Remove unnecessary lambda expression - - [Theory, MemberData(nameof(UnsupportedActions))] + [SuppressMessage("Style", "IDE0200:Remove unnecessary lambda expression", Justification = "Consistency")] + public static IEnumerable UnsupportedActions() => + [ + () => SomeSingleton.List.Add(new object()), + () => SomeSingleton.Collection.Clear(), + () => SomeSingleton.Collection.Remove(SomeSingleton.Item), + () => SomeSingleton.List.RemoveAt(0), + () => SomeSingleton.List.Insert(0, new object()), + () => SomeSingleton.List[0] = new object(), + ]; + + [Test] + [MethodDataSource(nameof(UnsupportedActions))] public void TestUnsupportedMethodShouldThrow(Action unsupportedAction) { _ = Assert.Throws(unsupportedAction); } - [Fact] + [Test] public void TestIndexingPastZeroShouldThrow() { _ = Assert.Throws(() => SomeSingleton.List[1]); diff --git a/Tests/SuperLinq.Test/RightOuterJoin.cs b/Tests/SuperLinq.Tests/RightOuterJoin.cs similarity index 84% rename from Tests/SuperLinq.Test/RightOuterJoin.cs rename to Tests/SuperLinq.Tests/RightOuterJoin.cs index ce6fa6d2b..82376643a 100644 --- a/Tests/SuperLinq.Test/RightOuterJoin.cs +++ b/Tests/SuperLinq.Tests/RightOuterJoin.cs @@ -1,6 +1,6 @@ -using static Test.JoinOperation; +using static SuperLinq.Tests.JoinOperation; -namespace Test; +namespace SuperLinq.Tests; public sealed class RightOuterJoinTest { @@ -8,7 +8,8 @@ public sealed class RightOuterJoinTest IEnumerable<(string, string)> left, IEnumerable<(string, string)> right, JoinOperation op, - bool passProjectors) => + bool passProjectors + ) => (op, passProjectors) switch { (Hash, false) => left.RightOuterHashJoin(right, l => l.Item1, r => r.Item1, StringComparer.OrdinalIgnoreCase), @@ -19,10 +20,11 @@ public sealed class RightOuterJoinTest _ => throw new NotSupportedException(), }; - public static IEnumerable GetRightOuterJoins() => - new[] { Hash, Merge }.Cartesian([false, true], (x, y) => new object[] { x, y }); + public static IEnumerable<(JoinOperation op, bool passProjectors)> GetRightOuterJoins() => + new[] { Hash, Merge }.Cartesian([false, true]); - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public void RightOuterJoinIsLazy(JoinOperation op, bool passProjectors) { var xs = new BreakingSequence<(string, string)>(); @@ -31,7 +33,8 @@ public void RightOuterJoinIsLazy(JoinOperation op, bool passProjectors) _ = ExecuteJoin(xs, ys, op, passProjectors); } - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public void RightOuterJoinResults(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -55,7 +58,8 @@ public void RightOuterJoinResults(JoinOperation op, bool passProjectors) (default, quux)); } - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public void RightOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); @@ -72,7 +76,8 @@ public void RightOuterJoinEmptyLeft(JoinOperation op, bool passProjectors) (default, baz)); } - [Theory, MemberData(nameof(GetRightOuterJoins))] + [Test] + [MethodDataSource(nameof(GetRightOuterJoins))] public void RightOuterJoinEmptyRight(JoinOperation op, bool passProjectors) { var foo = ("one", "foo"); diff --git a/Tests/SuperLinq.Test/RunLengthEncodeTest.cs b/Tests/SuperLinq.Tests/RunLengthEncodeTest.cs similarity index 96% rename from Tests/SuperLinq.Test/RunLengthEncodeTest.cs rename to Tests/SuperLinq.Tests/RunLengthEncodeTest.cs index 299351007..b7ef282ec 100644 --- a/Tests/SuperLinq.Test/RunLengthEncodeTest.cs +++ b/Tests/SuperLinq.Tests/RunLengthEncodeTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the RunLengthEncode() operator @@ -8,7 +8,7 @@ public sealed class RunLengthEncodeTests /// /// Verify that the RunLengthEncode() methods behave in a lazy manner. /// - [Fact] + [Test] public void TestRunLengthEncodeIsLazy() { _ = new BreakingSequence().RunLengthEncode(); @@ -18,7 +18,7 @@ public void TestRunLengthEncodeIsLazy() /// /// Verify that run-length encoding an empty sequence results in an empty sequence. /// - [Fact] + [Test] public void TestRunLengthEncodeEmptySequence() { using var sequence = TestingSequence.Of(); @@ -30,7 +30,7 @@ public void TestRunLengthEncodeEmptySequence() /// /// Verify that run-length encoding correctly accepts and uses custom equality comparers. /// - [Fact] + [Test] public void TestRunLengthEncodeCustomComparer() { using var sequence = TestingSequence.Of("a", "A", "a", "b", "b", "B", "B"); @@ -48,7 +48,7 @@ public void TestRunLengthEncodeCustomComparer() /// /// Verify that run-length encoding a known sequence produced a correct result. /// - [Fact] + [Test] public void TestRunLengthEncodeResults() { using var sequence = TestingSequence.Of(1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6); @@ -61,7 +61,7 @@ public void TestRunLengthEncodeResults() /// /// Verify that run-length encoding a sequence with no runs produces a correct result. /// - [Fact] + [Test] public void TestRunLengthEncodeNoRuns() { using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -75,7 +75,7 @@ public void TestRunLengthEncodeNoRuns() /// Verify that run-length encoding a sequence consisting of a single repeated value /// produces a correct result. /// - [Fact] + [Test] public void TestRunLengthEncodeOneRun() { using var sequence = Enumerable.Repeat('q', 10).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ScanByTest.cs b/Tests/SuperLinq.Tests/ScanByTest.cs similarity index 97% rename from Tests/SuperLinq.Test/ScanByTest.cs rename to Tests/SuperLinq.Tests/ScanByTest.cs index 617c4d195..b09b8d972 100644 --- a/Tests/SuperLinq.Test/ScanByTest.cs +++ b/Tests/SuperLinq.Tests/ScanByTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ScanByTest { - [Fact] + [Test] public void ScanByIsLazy() { _ = new BreakingSequence().ScanBy( @@ -11,7 +11,7 @@ public void ScanByIsLazy() BreakingFunc.Of()); } - [Fact] + [Test] public void ScanBy() { using var source = TestingSequence.Of( @@ -41,7 +41,7 @@ public void ScanBy() ('c', ("carlos", 'C', 100))); } - [Fact] + [Test] public void ScanByWithSecondOccurenceImmediatelyAfterFirst() { using var source = "jaffer".AsTestingSequence(); @@ -51,7 +51,7 @@ public void ScanByWithSecondOccurenceImmediatelyAfterFirst() result.AssertSequenceEqual(('j', 0), ('a', 0), ('f', 0), ('f', 1), ('e', 0), ('r', 0)); } - [Fact] + [Test] public void ScanByWithEqualityComparer() { using var source = TestingSequence.Of("a", "B", "c", "A", "b", "A"); @@ -66,7 +66,7 @@ public void ScanByWithEqualityComparer() result.AssertSequenceEqual(("a", 0), ("B", 0), ("c", 0), ("A", 1), ("b", 1), ("A", 2)); } - [Fact] + [Test] public void ScanByWithSomeNullKeys() { using var source = TestingSequence.Of("foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo"); @@ -75,7 +75,7 @@ public void ScanByWithSomeNullKeys() result.AssertSequenceEqual(("foo", 0), (null, 0), ("bar", 0), ("baz", 0), (null, 1), (null, 2), ("baz", 1), ("bar", 1), (null, 3), ("foo", 1)); } - [Fact] + [Test] public void ScanByWithNullSeed() { using var source = TestingSequence.Of("foo", null, "bar", null, "baz"); @@ -86,7 +86,7 @@ public void ScanByWithNullSeed() result.AssertSequenceEqual(("foo", nil), (null, nil), ("bar", nil), (null, nil), ("baz", nil)); } - [Fact] + [Test] public void ScanByDoesNotIterateUnnecessaryElements() { using var source = SuperEnumerable diff --git a/Tests/SuperLinq.Test/ScanRightTest.cs b/Tests/SuperLinq.Tests/ScanRightTest.cs similarity index 93% rename from Tests/SuperLinq.Test/ScanRightTest.cs rename to Tests/SuperLinq.Tests/ScanRightTest.cs index 1e6acc23c..8318a34d8 100644 --- a/Tests/SuperLinq.Test/ScanRightTest.cs +++ b/Tests/SuperLinq.Tests/ScanRightTest.cs @@ -1,12 +1,12 @@ using System.Globalization; -namespace Test; +namespace SuperLinq.Tests; public sealed class ScanRightTest { // ScanRight(source, func) - [Fact] + [Test] public void ScanRightWithEmptySequence() { using var seq = TestingSequence.Of(); @@ -15,7 +15,7 @@ public void ScanRightWithEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void ScanRightFuncIsNotInvokedOnSingleElementSequence() { using var seq = TestingSequence.Of(1); @@ -24,7 +24,7 @@ public void ScanRightFuncIsNotInvokedOnSingleElementSequence() result.AssertSequenceEqual(1); } - [Fact] + [Test] public void ScanRight() { using var seq = Enumerable.Range(1, 5) @@ -38,7 +38,7 @@ public void ScanRight() "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5"); } - [Fact] + [Test] public void ScanRightWithList() { var list = Enumerable.Range(1, 5) @@ -52,7 +52,7 @@ public void ScanRightWithList() "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5"); } - [Fact] + [Test] public void ScanRightIsLazy() { _ = new BreakingSequence().ScanRight(BreakingFunc.Of()); @@ -60,10 +60,10 @@ public void ScanRightIsLazy() // ScanRight(source, seed, func) - [Theory] - [InlineData(5)] - [InlineData("c")] - [InlineData(true)] + [Test] + [Arguments(5)] + [Arguments("c")] + [Arguments(true)] public void ScanRightSeedWithEmptySequence(object defaultValue) { using var seq = TestingSequence.Of(); @@ -72,7 +72,7 @@ public void ScanRightSeedWithEmptySequence(object defaultValue) result.AssertSequenceEqual(defaultValue); } - [Fact] + [Test] public void ScanRightSeedFuncIsNotInvokedOnEmptySequence() { using var seq = TestingSequence.Of(); @@ -81,7 +81,7 @@ public void ScanRightSeedFuncIsNotInvokedOnEmptySequence() result.AssertSequenceEqual(1); } - [Fact] + [Test] public void ScanRightSeed() { using var seq = Enumerable.Range(1, 4).AsTestingSequence(); @@ -93,7 +93,7 @@ public void ScanRightSeed() "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5"); } - [Fact] + [Test] public void ScanRightSeedWithList() { var list = Enumerable.Range(1, 4).ToList(); @@ -105,7 +105,7 @@ public void ScanRightSeedWithList() "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5"); } - [Fact] + [Test] public void ScanRightSeedIsLazy() { _ = new BreakingSequence().ScanRight("", BreakingFunc.Of()); diff --git a/Tests/SuperLinq.Test/ScanTest.cs b/Tests/SuperLinq.Tests/ScanTest.cs similarity index 94% rename from Tests/SuperLinq.Test/ScanTest.cs rename to Tests/SuperLinq.Tests/ScanTest.cs index bd99f3bb5..61336d18b 100644 --- a/Tests/SuperLinq.Test/ScanTest.cs +++ b/Tests/SuperLinq.Tests/ScanTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ScanTest { - [Fact] + [Test] public void ScanEmpty() { using var seq = TestingSequence.Of(); @@ -11,7 +11,7 @@ public void ScanEmpty() result.AssertSequenceEqual(); } - [Fact] + [Test] public void ScanSum() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -20,13 +20,13 @@ public void ScanSum() result.AssertSequenceEqual(1, 3, 6, 10, 15, 21, 28, 36, 45, 55); } - [Fact] + [Test] public void ScanIsLazy() { _ = new BreakingSequence().Scan(BreakingFunc.Of()); } - [Fact] + [Test] public void ScanDoesNotIterateExtra() { using var seq = SeqExceptionAt(4).AsTestingSequence(maxEnumerations: 2); @@ -37,7 +37,7 @@ public void ScanDoesNotIterateExtra() result.Take(3).AssertSequenceEqual(1, 3, 6); } - [Fact] + [Test] public void SeededScanEmpty() { using var seq = TestingSequence.Of(); @@ -46,7 +46,7 @@ public void SeededScanEmpty() Assert.Equal(-1, result.Single()); } - [Fact] + [Test] public void SeededScanSum() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -55,14 +55,14 @@ public void SeededScanSum() result.AssertSequenceEqual(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55); } - [Fact] + [Test] public void SeededScanIsLazy() { _ = new BreakingSequence().Scan(seed: null, BreakingFunc.Of()); } - [Fact] + [Test] public void SeededScanDoesNotIterateExtra() { using var seq = SeqExceptionAt(4).AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Test/SegmentTest.cs b/Tests/SuperLinq.Tests/SegmentTest.cs similarity index 78% rename from Tests/SuperLinq.Test/SegmentTest.cs rename to Tests/SuperLinq.Tests/SegmentTest.cs index 2fc1ed63d..3b6ede017 100644 --- a/Tests/SuperLinq.Test/SegmentTest.cs +++ b/Tests/SuperLinq.Tests/SegmentTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Segment operator @@ -8,7 +8,7 @@ public sealed class SegmentTests /// /// Verify that the Segment operator behaves in a lazy manner /// - [Fact] + [Test] public void TestSegmentIsLazy() { _ = new BreakingSequence().Segment(BreakingFunc.Of()); @@ -19,7 +19,7 @@ public void TestSegmentIsLazy() /// /// Verify that segmenting a sequence into a single sequence results in the original sequence. /// - [Fact] + [Test] public void TestIdentitySegment() { using var sequence = Enumerable.Range(1, 5) @@ -31,7 +31,7 @@ public void TestIdentitySegment() /// /// Verify that segmenting an empty sequence results in an empty sequence of segments. /// - [Fact] + [Test] public void TestEmptySequence() { using var sequence = Array.Empty().AsTestingSequence(); @@ -41,7 +41,7 @@ public void TestEmptySequence() /// /// Verify that the segments returned can be enumerated more than once. /// - [Fact] + [Test] public void TestSegmentIsIdempotent() { using var sequence = Enumerable.Repeat(-1, 10) @@ -59,7 +59,7 @@ public void TestSegmentIsIdempotent() /// Verify that the first segment is never empty. By definition, segmentation /// begins with the second element in the source sequence. /// - [Fact] + [Test] public void TestFirstSegmentNeverEmpty() { using (var sequence = Enumerable.Repeat(-1, 10).AsTestingSequence()) @@ -75,7 +75,7 @@ public void TestFirstSegmentNeverEmpty() /// /// Verify invariant that segmentation begins with second element of source sequence. /// - [Fact] + [Test] public void TestSegmentationStartsWithSecondItem() { using (var sequence = TestingSequence.Of(0)) @@ -91,7 +91,7 @@ public void TestSegmentationStartsWithSecondItem() /// /// Verify we can segment a source sequence by it's zero-based index /// - [Fact] + [Test] public void VerifyCanSegmentByIndex() { @@ -106,7 +106,7 @@ public void VerifyCanSegmentByIndex() /// /// Verify that we can segment a source sequence by the change in adjacent items /// - [Fact] + [Test] public void VerifyCanSegmentByPrevious() { var sequence = Enumerable.Range(1, 3) @@ -121,24 +121,17 @@ public void VerifyCanSegmentByPrevious() Assert.True(result.All(s => s.Count == 5)); } - public static IEnumerable TestData { get; } = - from e in new[] - { - // input sequence is empty - new { Source = Seq(), Expected = Seq>() }, - // input sequence contains only new segment start - new { Source = Seq(0, 3, 6), Expected = Seq(Seq(0), Seq(3), Seq(6)) }, - // input sequence do not contains new segment start - new { Source = Seq(1, 2, 4, 5), Expected = Seq(Seq(1, 2, 4, 5)) }, - // input sequence start with a segment start - new { Source = Seq(0, 1, 2, 3, 4, 5), Expected = Seq(Seq(0, 1, 2), Seq(3, 4, 5)) }, - // input sequence do not start with a segment start - new { Source = Seq(1, 2, 3, 4, 5), Expected = Seq(Seq(1, 2), Seq(3, 4, 5)) }, - } - select new object[] { e.Source, e.Expected }; - - [Theory] - [MemberData(nameof(TestData))] + public static IEnumerable<(IEnumerable source, IEnumerable> expectedSegments)> TestData() => + [ + ([], [[]] ), + ([0, 3, 6], [[0], [3], [6]] ), + ([1, 2, 4, 5], [[1, 2, 4, 5]] ), + ([0, 1, 2, 3, 4, 5], [[0, 1, 2], [3, 4, 5]]), + ([1, 2, 3, 4, 5], [[1, 2], [3, 4, 5]] ), + ]; + + [Test] + [MethodDataSource(nameof(TestData))] public void TestSegment(IEnumerable source, IEnumerable> expectedSegments) { using var sequence = source.AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/SequenceReader.cs b/Tests/SuperLinq.Tests/SequenceReader.cs similarity index 98% rename from Tests/SuperLinq.Test/SequenceReader.cs rename to Tests/SuperLinq.Tests/SequenceReader.cs index 4c1eb1cb9..2bb073d2e 100644 --- a/Tests/SuperLinq.Test/SequenceReader.cs +++ b/Tests/SuperLinq.Tests/SequenceReader.cs @@ -1,6 +1,6 @@ using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; internal static class SequenceReader { diff --git a/Tests/SuperLinq.Test/SequenceTest.cs b/Tests/SuperLinq.Tests/SequenceTest.cs similarity index 62% rename from Tests/SuperLinq.Test/SequenceTest.cs rename to Tests/SuperLinq.Tests/SequenceTest.cs index 063a3f2f0..54b7c9383 100644 --- a/Tests/SuperLinq.Test/SequenceTest.cs +++ b/Tests/SuperLinq.Tests/SequenceTest.cs @@ -1,27 +1,27 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class SequenceTest { - [Theory] - [InlineData(65600, 65536, 65536)] - [InlineData(0, -1, 2)] - [InlineData(-65600, 65536, -65536)] - [InlineData(int.MaxValue - 1, 2, 2)] + [Test] + [Arguments(65600, 65536, 65536)] + [Arguments(0, -1, 2)] + [Arguments(-65600, 65536, -65536)] + [Arguments(int.MaxValue - 1, 2, 2)] public void RangeThrowsOutOfRange(int start, int count, int step) { _ = Assert.Throws(() => SuperEnumerable.Range(start, count, step)); } - [Theory] - [InlineData(1, 2, 3)] - [InlineData(1, 2, -3)] - [InlineData(-32, 10, 30)] - [InlineData(32, 10, -30)] - [InlineData(-32, 10, 0)] - [InlineData(32, 10, -0)] - [InlineData(10, 0, 12)] - [InlineData(-10, 0, 12)] + [Test] + [Arguments(1, 2, 3)] + [Arguments(1, 2, -3)] + [Arguments(-32, 10, 30)] + [Arguments(32, 10, -30)] + [Arguments(-32, 10, 0)] + [Arguments(32, 10, -0)] + [Arguments(10, 0, 12)] + [Arguments(-10, 0, 12)] public void Range(int start, int count, int step) { var result = SuperEnumerable.Range(start, count, step); @@ -35,12 +35,12 @@ public void Range(int start, int count, int step) .Select(i => start + (step * i))); } - [Theory] - [InlineData(-10, -4)] - [InlineData(-1, 5)] - [InlineData(1, 10)] - [InlineData(30, 55)] - [InlineData(27, 172)] + [Test] + [Arguments(-10, -4)] + [Arguments(-1, 5)] + [Arguments(1, 10)] + [Arguments(30, 55)] + [Arguments(27, 172)] public void SequenceWithAscendingRange(int start, int stop) { var result = SuperEnumerable.Sequence(start, stop); @@ -52,12 +52,12 @@ public void SequenceWithAscendingRange(int start, int stop) result.AssertSequenceEqual(Enumerable.Range(start, stop - start + 1)); } - [Theory] - [InlineData(-4, -10)] - [InlineData(5, -1)] - [InlineData(10, 1)] - [InlineData(55, 30)] - [InlineData(172, 27)] + [Test] + [Arguments(-4, -10)] + [Arguments(5, -1)] + [Arguments(10, 1)] + [Arguments(55, 30)] + [Arguments(172, 27)] public void SequenceWithDescendingRange(int start, int stop) { var result = SuperEnumerable.Sequence(start, stop); @@ -69,12 +69,12 @@ public void SequenceWithDescendingRange(int start, int stop) result.AssertSequenceEqual(Enumerable.Range(stop, start - stop + 1).Reverse()); } - [Theory] - [InlineData(-10, -4, 2)] - [InlineData(-1, 5, 3)] - [InlineData(1, 10, 1)] - [InlineData(30, 55, 4)] - [InlineData(27, 172, 9)] + [Test] + [Arguments(-10, -4, 2)] + [Arguments(-1, 5, 3)] + [Arguments(1, 10, 1)] + [Arguments(30, 55, 4)] + [Arguments(27, 172, 9)] public void SequenceWithAscendingRangeAscendingStep(int start, int stop, int step) { var result = SuperEnumerable.Sequence(start, stop, step); @@ -83,12 +83,12 @@ public void SequenceWithAscendingRangeAscendingStep(int start, int stop, int ste result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(-10, -4, -2)] - [InlineData(-1, 5, -3)] - [InlineData(1, 10, -1)] - [InlineData(30, 55, -4)] - [InlineData(27, 172, -9)] + [Test] + [Arguments(-10, -4, -2)] + [Arguments(-1, 5, -3)] + [Arguments(1, 10, -1)] + [Arguments(30, 55, -4)] + [Arguments(27, 172, -9)] public void SequenceWithAscendingRangeDescendingStep(int start, int stop, int step) { var result = SuperEnumerable.Sequence(start, stop, step); @@ -96,12 +96,12 @@ public void SequenceWithAscendingRangeDescendingStep(int start, int stop, int st Assert.Empty(result); } - [Theory] - [InlineData(-4, -10, 2)] - [InlineData(5, -1, 3)] - [InlineData(10, 1, 1)] - [InlineData(55, 30, 4)] - [InlineData(172, 27, 9)] + [Test] + [Arguments(-4, -10, 2)] + [Arguments(5, -1, 3)] + [Arguments(10, 1, 1)] + [Arguments(55, 30, 4)] + [Arguments(172, 27, 9)] public void SequenceWithDescendingRangeAscendingStep(int start, int stop, int step) { var result = SuperEnumerable.Sequence(start, stop, step); @@ -109,12 +109,12 @@ public void SequenceWithDescendingRangeAscendingStep(int start, int stop, int st Assert.Empty(result); } - [Theory] - [InlineData(-4, -10, -2)] - [InlineData(5, -1, -3)] - [InlineData(10, 1, -1)] - [InlineData(55, 30, -4)] - [InlineData(172, 27, -9)] + [Test] + [Arguments(-4, -10, -2)] + [Arguments(5, -1, -3)] + [Arguments(10, 1, -1)] + [Arguments(55, 30, -4)] + [Arguments(172, 27, -9)] public void SequenceWithDescendingRangeDescendigStep(int start, int stop, int step) { var result = SuperEnumerable.Sequence(start, stop, step); @@ -123,16 +123,16 @@ public void SequenceWithDescendingRangeDescendigStep(int start, int stop, int st result.AssertSequenceEqual(expectations); } - [Theory] - [InlineData(int.MaxValue, int.MaxValue, -1)] - [InlineData(int.MaxValue, int.MaxValue, 1)] - [InlineData(int.MaxValue, int.MaxValue, null)] - [InlineData(0, 0, -1)] - [InlineData(0, 0, 1)] - [InlineData(0, 0, null)] - [InlineData(int.MinValue, int.MinValue, -1)] - [InlineData(int.MinValue, int.MinValue, 1)] - [InlineData(int.MinValue, int.MinValue, null)] + [Test] + [Arguments(int.MaxValue, int.MaxValue, -1)] + [Arguments(int.MaxValue, int.MaxValue, 1)] + [Arguments(int.MaxValue, int.MaxValue, null)] + [Arguments(0, 0, -1)] + [Arguments(0, 0, 1)] + [Arguments(0, 0, null)] + [Arguments(int.MinValue, int.MinValue, -1)] + [Arguments(int.MinValue, int.MinValue, 1)] + [Arguments(int.MinValue, int.MinValue, null)] public void SequenceWithStartEqualsStop(int start, int stop, int? step) { var result = step.HasValue @@ -142,11 +142,11 @@ public void SequenceWithStartEqualsStop(int start, int stop, int? step) Assert.Equal(result.Single(), start); } - [Theory] - [InlineData(int.MaxValue - 1, int.MaxValue, 1, 2)] - [InlineData(int.MinValue + 1, int.MinValue, -1, 2)] - [InlineData(0, int.MaxValue, 10000000, (int.MaxValue / 10000000) + 1)] - [InlineData(int.MinValue, int.MaxValue, int.MaxValue, 3)] + [Test] + [Arguments(int.MaxValue - 1, int.MaxValue, 1, 2)] + [Arguments(int.MinValue + 1, int.MinValue, -1, 2)] + [Arguments(0, int.MaxValue, 10000000, (int.MaxValue / 10000000) + 1)] + [Arguments(int.MinValue, int.MaxValue, int.MaxValue, 3)] public void SequenceEdgeCases(int start, int stop, int step, int count) { var result = SuperEnumerable.Sequence(start, stop, step); @@ -154,10 +154,10 @@ public void SequenceEdgeCases(int start, int stop, int step, int count) Assert.Equal(result.Count(), count); } - [Theory] - [InlineData(5, 10)] - [InlineData(int.MaxValue, int.MaxValue)] - [InlineData(int.MinValue, int.MaxValue)] + [Test] + [Arguments(5, 10)] + [Arguments(int.MaxValue, int.MaxValue)] + [Arguments(int.MinValue, int.MaxValue)] public void SequenceWithStepZero(int start, int stop) { var result = SuperEnumerable.Sequence(start, stop, 0); @@ -165,7 +165,7 @@ public void SequenceWithStepZero(int start, int stop) Assert.True(result.Take(100).All(x => x == start)); } - [Fact] + [Test] public void SequenceListBehavior() { var result = SuperEnumerable.Sequence(0, 9_999); diff --git a/Tests/SuperLinq.Test/ShareTest.cs b/Tests/SuperLinq.Tests/ShareTest.cs similarity index 97% rename from Tests/SuperLinq.Test/ShareTest.cs rename to Tests/SuperLinq.Tests/ShareTest.cs index ab31f4b87..ded61d5bf 100644 --- a/Tests/SuperLinq.Test/ShareTest.cs +++ b/Tests/SuperLinq.Tests/ShareTest.cs @@ -1,16 +1,16 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; public sealed class ShareTest { - [Fact] + [Test] public void ShareIsLazy() { _ = new BreakingSequence().Share(); } - [Fact] + [Test] public void ShareWithSingleConsumer() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -20,7 +20,7 @@ public void ShareWithSingleConsumer() Assert.Equal(0, result.Count); } - [Fact] + [Test] public void ShareWithMultipleConsumers() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -45,7 +45,7 @@ public void ShareWithMultipleConsumers() r2.ReadEnd(); } - [Fact] + [Test] public void ShareWithInnerConsumer() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -72,7 +72,7 @@ public void ShareWithInnerConsumer() r1.ReadEnd(); } - [Fact] + [Test] public void ShareWithSequentialPartialConsumers() { using var seq = Enumerable.Range(1, 10).AsTestingSequence(); @@ -102,7 +102,7 @@ public void ShareWithSequentialPartialConsumers() r3.ReadEnd(); } - [Fact] + [Test] public void ShareDisposesAfterSourceIsIteratedEntirely() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -113,7 +113,7 @@ public void ShareDisposesAfterSourceIsIteratedEntirely() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public void ShareDisposesWithPartialEnumeration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -126,7 +126,7 @@ public void ShareDisposesWithPartialEnumeration() Assert.True(seq.IsDisposed); } - [Fact] + [Test] public void ShareRestartsAfterReset() { var starts = 0; @@ -149,7 +149,7 @@ IEnumerable TestSequence() Assert.Equal(2, starts); } - [Fact] + [Test] public void ShareThrowsWhenCacheDisposedDuringIteration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -164,7 +164,7 @@ public void ShareThrowsWhenCacheDisposedDuringIteration() () => reader.Read()); } - [Fact] + [Test] public void ShareThrowsWhenResetDuringIteration() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -180,7 +180,7 @@ public void ShareThrowsWhenResetDuringIteration() Assert.Equal("Buffer reset during iteration.", ex.Message); } - [Fact] + [Test] public void ShareThrowsWhenGettingIteratorAfterDispose() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -192,7 +192,7 @@ public void ShareThrowsWhenGettingIteratorAfterDispose() buffer.Consume); } - [Fact] + [Test] public void ShareThrowsWhenResettingAfterDispose() { using var seq = Enumerable.Range(0, 10).AsTestingSequence(); @@ -204,7 +204,7 @@ public void ShareThrowsWhenResettingAfterDispose() buffer.Reset); } - [Fact] + [Test] public void ShareRethrowsErrorDuringIterationToAllIteratorsUntilReset() { using var xs = SeqExceptionAt(2).AsTestingSequence(maxEnumerations: 2); @@ -229,7 +229,7 @@ public void ShareRethrowsErrorDuringIterationToAllIteratorsUntilReset() Assert.Equal(1, r1.Read()); } - [Fact] + [Test] public void ShareRethrowsErrorDuringFirstIterationStartToAllIterationsUntilReset() { using var seq = new FailingEnumerable().AsTestingSequence(maxEnumerations: 2); diff --git a/Tests/SuperLinq.Test/ShuffleTest.cs b/Tests/SuperLinq.Tests/ShuffleTest.cs similarity index 94% rename from Tests/SuperLinq.Test/ShuffleTest.cs rename to Tests/SuperLinq.Tests/ShuffleTest.cs index 52a71750c..8be3bb349 100644 --- a/Tests/SuperLinq.Test/ShuffleTest.cs +++ b/Tests/SuperLinq.Tests/ShuffleTest.cs @@ -1,16 +1,16 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ShuffleTest { private static readonly Random s_seed = new(12345); - [Fact] + [Test] public void ShuffleIsLazy() { _ = new BreakingSequence().Shuffle(); } - [Fact] + [Test] public void Shuffle() { using var source = Enumerable.Range(1, 100).AsTestingSequence(); @@ -19,7 +19,7 @@ public void Shuffle() result.AssertCollectionEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public void ShuffleWithEmptySequence() { using var source = Enumerable.Empty().AsTestingSequence(); @@ -28,7 +28,7 @@ public void ShuffleWithEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void ShuffleIsIdempotent() { var sequence = Enumerable.Range(1, 100).ToArray(); @@ -40,13 +40,13 @@ public void ShuffleIsIdempotent() sequence.AssertSequenceEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public void ShuffleSeedIsLazy() { _ = new BreakingSequence().Shuffle(s_seed); } - [Fact] + [Test] public void ShuffleSeed() { using var source = Enumerable.Range(1, 100).AsTestingSequence(); @@ -55,7 +55,7 @@ public void ShuffleSeed() result.AssertCollectionEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public void ShuffleSeedWithEmptySequence() { using var source = Enumerable.Empty().AsTestingSequence(); @@ -64,7 +64,7 @@ public void ShuffleSeedWithEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void ShuffleSeedIsIdempotent() { var sequence = Enumerable.Range(1, 100).ToArray(); diff --git a/Tests/SuperLinq.Test/SkipUntilTest.cs b/Tests/SuperLinq.Tests/SkipUntilTest.cs similarity index 63% rename from Tests/SuperLinq.Test/SkipUntilTest.cs rename to Tests/SuperLinq.Tests/SkipUntilTest.cs index de7d555ec..22d1433e8 100644 --- a/Tests/SuperLinq.Test/SkipUntilTest.cs +++ b/Tests/SuperLinq.Tests/SkipUntilTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class SkipUntilTest { - [Fact] + [Test] public void SkipUntilPredicateNeverFalse() { using var sequence = Enumerable.Range(0, 5) @@ -12,7 +12,7 @@ public void SkipUntilPredicateNeverFalse() .AssertSequenceEqual(1, 2, 3, 4); } - [Fact] + [Test] public void SkipUntilPredicateNeverTrue() { using var sequence = Enumerable.Range(0, 5) @@ -20,7 +20,7 @@ public void SkipUntilPredicateNeverTrue() Assert.Empty(sequence.SkipUntil(x => x == 100)); } - [Fact] + [Test] public void SkipUntilPredicateBecomesTrueHalfWay() { using var sequence = Enumerable.Range(0, 5) @@ -30,13 +30,13 @@ public void SkipUntilPredicateBecomesTrueHalfWay() .AssertSequenceEqual(3, 4); } - [Fact] + [Test] public void SkipUntilEvaluatesSourceLazily() { _ = new BreakingSequence().SkipUntil(x => x.Length == 0); } - [Fact] + [Test] public void SkipUntilEvaluatesPredicateLazily() { using var sequence = Enumerable.Range(-2, 5) @@ -48,19 +48,20 @@ public void SkipUntilEvaluatesPredicateLazily() .AssertSequenceEqual(0, 1, 2); } - public static IEnumerable TestData { get; } = + public static IEnumerable<(int[] source, int min, int[] expected)> TestData() => [ - [Array.Empty(), 0, Array.Empty()], // empty sequence - [new[] { 0 }, 0, Array.Empty()], // one-item sequence, predicate succeed - [new[] { 0 }, 1, Array.Empty()], // one-item sequence, predicate don't succeed - [new[] { 1, 2, 3 }, 0, new[] { 2, 3 }], // predicate succeed on first item - [new[] { 1, 2, 3 }, 1, new[] { 2, 3 }], - [new[] { 1, 2, 3 }, 2, new[] { 3 }], - [new[] { 1, 2, 3 }, 3, Array.Empty()], // predicate succeed on last item - [new[] { 1, 2, 3 }, 4, Array.Empty()], // predicate never succeed + ([], 0, []), + ([0], 0, []), + ([0], 1, []), + ([1, 2, 3], 0, [2, 3]), + ([1, 2, 3], 1, [2, 3]), + ([1, 2, 3], 2, [3]), + ([1, 2, 3], 3, []), + ([1, 2, 3], 4, []), ]; - [Theory, MemberData(nameof(TestData))] + [Test] + [MethodDataSource(nameof(TestData))] public void TestSkipUntil(int[] source, int min, int[] expected) { using var xs = source.AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/SliceTest.cs b/Tests/SuperLinq.Tests/SliceTest.cs similarity index 74% rename from Tests/SuperLinq.Test/SliceTest.cs rename to Tests/SuperLinq.Tests/SliceTest.cs index 99d647af7..c224d3cf9 100644 --- a/Tests/SuperLinq.Test/SliceTest.cs +++ b/Tests/SuperLinq.Tests/SliceTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Slice operator @@ -8,19 +8,18 @@ public sealed class SliceTests /// /// Verify that Slice evaluates in a lazy manner. /// - [Fact] + [Test] public void TestSliceIsLazy() { _ = new BreakingSequence().Slice(10, 10); } - public static IEnumerable GetSequences() => + public static IEnumerable> GetSequences() => Enumerable.Range(1, 5) - .GetCollectionSequences() - .Select(x => new object[] { x }); + .GetCollectionSequences(); - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void TestSliceIdentity(IDisposableEnumerable seq) { using (seq) @@ -30,8 +29,8 @@ public void TestSliceIdentity(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void TestSliceFirstItem(IDisposableEnumerable seq) { using (seq) @@ -41,8 +40,8 @@ public void TestSliceFirstItem(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void TestSliceLastItem(IDisposableEnumerable seq) { using (seq) @@ -52,8 +51,8 @@ public void TestSliceLastItem(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void TestSliceSmallerThanSequence(IDisposableEnumerable seq) { using (seq) @@ -63,8 +62,8 @@ public void TestSliceSmallerThanSequence(IDisposableEnumerable seq) } } - [Theory] - [MemberData(nameof(GetSequences))] + [Test] + [MethodDataSource(nameof(GetSequences))] public void TestSliceLongerThanSequence(IDisposableEnumerable seq) { using (seq) diff --git a/Tests/SuperLinq.Test/SortedMergeByTest.cs b/Tests/SuperLinq.Tests/SortedMergeByTest.cs similarity index 98% rename from Tests/SuperLinq.Test/SortedMergeByTest.cs rename to Tests/SuperLinq.Tests/SortedMergeByTest.cs index 7144c31c6..ba6c4af9f 100644 --- a/Tests/SuperLinq.Test/SortedMergeByTest.cs +++ b/Tests/SuperLinq.Tests/SortedMergeByTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Tests that verify the behavior of the SortedMergeBy operator. @@ -8,7 +8,7 @@ public sealed class SortedMergeByTests /// /// Verify that SortedMergeBy behaves in a lazy manner. /// - [Fact] + [Test] public void TestSortedMergeByIsLazy() { var sequenceA = new BreakingSequence(); @@ -21,7 +21,7 @@ public void TestSortedMergeByIsLazy() /// Verify that SortedMergeBy disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public void TestSortedMergeByDisposesOnError() { using var sequenceA = TestingSequence.Of(); @@ -34,7 +34,7 @@ public void TestSortedMergeByDisposesOnError() /// /// Verify that SortedMergeBy sorts correctly with a comparer. /// - [Fact] + [Test] public void TestSortedMergeByComparerNull() { using var sequenceA = Enumerable.Range(1, 3).AsTestingSequence(); @@ -47,7 +47,7 @@ public void TestSortedMergeByComparerNull() /// /// Verify that if otherSequences is empty, SortedMergeBy yields the contents of sequence /// - [Fact] + [Test] public void TestSortedMergeByOtherSequencesEmpty() { using var sequenceA = Enumerable.Range(1, 10).AsTestingSequence(); @@ -59,7 +59,7 @@ public void TestSortedMergeByOtherSequencesEmpty() /// /// Verify that if all sequences passed to SortedMergeBy are empty, the result is an empty sequence. /// - [Fact] + [Test] public void TestSortedMergeByAllSequencesEmpty() { using var sequenceA = TestingSequence.Of(); @@ -73,7 +73,7 @@ public void TestSortedMergeByAllSequencesEmpty() /// /// Verify that if the primary sequence is empty, SortedMergeBy correctly merges otherSequences /// - [Fact] + [Test] public void TestSortedMergeByFirstSequenceEmpty() { using var sequenceA = TestingSequence.Of(); @@ -87,7 +87,7 @@ public void TestSortedMergeByFirstSequenceEmpty() /// /// Verify that SortedMergeBy correctly merges sequences of equal length. /// - [Fact] + [Test] public void TestSortedMergeByEqualLengthSequences() { using var sequenceA = Enumerable.Range(0, 10).Select(x => (x * 3) + 0).AsTestingSequence(); @@ -101,7 +101,7 @@ public void TestSortedMergeByEqualLengthSequences() /// /// Verify that sorted merge correctly merges sequences of unequal length. /// - [Fact] + [Test] public void TestSortedMergeByUnequalLengthSequences() { using var sequenceA = Enumerable.Range(0, 30).Select(x => (x * 3) + 0).AsTestingSequence(maxEnumerations: 2); @@ -116,7 +116,7 @@ public void TestSortedMergeByUnequalLengthSequences() /// /// Verify that sorted merge correctly uses a custom comparer supplied to it. /// - [Fact] + [Test] public void TestSortedMergeByCustomComparer() { using var sequenceA = new[] { "a", "D", "G", "h", "i", "J", "O", "t", "z" }.AsTestingSequence(maxEnumerations: 2); @@ -135,7 +135,7 @@ public void TestSortedMergeByCustomComparer() /// /// Verify that SortedMergeBy correctly merges sequences with overlapping contents. /// - [Fact] + [Test] public void TestSortedMergeByOverlappingSequences() { using var sequenceA = TestingSequence.Of(1, 3, 5, 7, 9, 11); diff --git a/Tests/SuperLinq.Test/SortedMergeTest.cs b/Tests/SuperLinq.Tests/SortedMergeTest.cs similarity index 97% rename from Tests/SuperLinq.Test/SortedMergeTest.cs rename to Tests/SuperLinq.Tests/SortedMergeTest.cs index 466061270..3adacf2e1 100644 --- a/Tests/SuperLinq.Test/SortedMergeTest.cs +++ b/Tests/SuperLinq.Tests/SortedMergeTest.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Tests that verify the behavior of the SortedMerge operator. @@ -8,7 +8,7 @@ public sealed class SortedMergeTests /// /// Verify that SortedMerge behaves in a lazy manner. /// - [Fact] + [Test] public void TestSortedMergeIsLazy() { var sequenceA = new BreakingSequence(); @@ -21,7 +21,7 @@ public void TestSortedMergeIsLazy() /// Verify that SortedMerge disposes those enumerators that it managed /// to open successfully /// - [Fact] + [Test] public void TestSortedMergeDisposesOnError() { using var sequenceA = TestingSequence.Of(); @@ -34,7 +34,7 @@ public void TestSortedMergeDisposesOnError() /// /// Verify that SortedMerge sorts correctly with a comparer. /// - [Fact] + [Test] public void TestSortedMergeComparerNull() { using var sequenceA = Enumerable.Range(1, 3).AsTestingSequence(); @@ -47,7 +47,7 @@ public void TestSortedMergeComparerNull() /// /// Verify that if otherSequences is empty, SortedMerge yields the contents of sequence /// - [Fact] + [Test] public void TestSortedMergeOtherSequencesEmpty() { using var sequenceA = Enumerable.Range(1, 10).AsTestingSequence(); @@ -59,7 +59,7 @@ public void TestSortedMergeOtherSequencesEmpty() /// /// Verify that if all sequences passed to SortedMerge are empty, the result is an empty sequence. /// - [Fact] + [Test] public void TestSortedMergeAllSequencesEmpty() { using var sequenceA = TestingSequence.Of(); @@ -73,7 +73,7 @@ public void TestSortedMergeAllSequencesEmpty() /// /// Verify that if the primary sequence is empty, SortedMerge correctly merges otherSequences /// - [Fact] + [Test] public void TestSortedMergeFirstSequenceEmpty() { using var sequenceA = TestingSequence.Of(); @@ -87,7 +87,7 @@ public void TestSortedMergeFirstSequenceEmpty() /// /// Verify that SortedMerge correctly merges sequences of equal length. /// - [Fact] + [Test] public void TestSortedMergeEqualLengthSequences() { using var sequenceA = Enumerable.Range(0, 10).Select(x => (x * 3) + 0).AsTestingSequence(); @@ -101,7 +101,7 @@ public void TestSortedMergeEqualLengthSequences() /// /// Verify that sorted merge correctly merges sequences of unequal length. /// - [Fact] + [Test] public void TestSortedMergeUnequalLengthSequences() { using var sequenceA = Enumerable.Range(0, 30).Select(x => (x * 3) + 0).AsTestingSequence(maxEnumerations: 2); @@ -116,7 +116,7 @@ public void TestSortedMergeUnequalLengthSequences() /// /// Verify that sorted merge correctly uses a custom comparer supplied to it. /// - [Fact] + [Test] public void TestSortedMergeCustomComparer() { using var sequenceA = new[] { "a", "D", "G", "h", "i", "J", "O", "t", "z" }.AsTestingSequence(maxEnumerations: 2); @@ -135,7 +135,7 @@ public void TestSortedMergeCustomComparer() /// /// Verify that SortedMerge correctly merges sequences with overlapping contents. /// - [Fact] + [Test] public void TestSortedMergeOverlappingSequences() { using var sequenceA = TestingSequence.Of(1, 3, 5, 7, 9, 11); diff --git a/Tests/SuperLinq.Test/SplitTest.cs b/Tests/SuperLinq.Tests/SplitTest.cs similarity index 96% rename from Tests/SuperLinq.Test/SplitTest.cs rename to Tests/SuperLinq.Tests/SplitTest.cs index 46d123632..cd1cd8e14 100644 --- a/Tests/SuperLinq.Test/SplitTest.cs +++ b/Tests/SuperLinq.Tests/SplitTest.cs @@ -1,17 +1,17 @@ using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; public sealed class SplitTest { - [Fact] + [Test] public void SplitIsLazy() { _ = new BreakingSequence().Split(1); _ = new BreakingSequence().Split(1, 2); } - [Fact] + [Test] public void SplitWithComparer() { using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -19,7 +19,7 @@ public void SplitWithComparer() result.AssertSequenceEqual(Enumerable.Range(1, 5).Select(x => new[] { (x * 2) - 1 })); } - [Fact] + [Test] public void SplitWithComparerUptoMaxCount() { using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); @@ -27,7 +27,7 @@ public void SplitWithComparerUptoMaxCount() result.AssertSequenceEqual([1], [3], Enumerable.Range(5, 6)); } - [Fact] + [Test] [SuppressMessage("Style", "IDE0305:Simplify collection initialization")] public void SplitWithSeparatorAndResultTransformation() { @@ -36,7 +36,7 @@ public void SplitWithSeparatorAndResultTransformation() result.AssertSequenceEqual("the", "quick", "brown", "fox"); } - [Fact] + [Test] [SuppressMessage("Style", "IDE0305:Simplify collection initialization")] public void SplitUptoMaxCount() { @@ -45,7 +45,7 @@ public void SplitUptoMaxCount() result.AssertSequenceEqual("the", "quick", "brown fox"); } - [Fact] + [Test] public void SplitWithSeparatorSelector() { using var sequence = TestingSequence.Of(1, 2, null, 3, null, 4, 5, 6); @@ -58,7 +58,7 @@ public void SplitWithSeparatorSelector() reader.ReadEnd(); } - [Fact] + [Test] public void SplitWithSeparatorSelectorUptoMaxCount() { using var sequence = TestingSequence.Of(1, 2, null, 3, null, 4, 5, 6); diff --git a/Tests/SuperLinq.Test/StartsWithTest.cs b/Tests/SuperLinq.Tests/StartsWithTest.cs similarity index 75% rename from Tests/SuperLinq.Test/StartsWithTest.cs rename to Tests/SuperLinq.Tests/StartsWithTest.cs index dc4a2deed..a56d564f2 100644 --- a/Tests/SuperLinq.Test/StartsWithTest.cs +++ b/Tests/SuperLinq.Tests/StartsWithTest.cs @@ -1,11 +1,11 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class StartsWithTest { - [Theory] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] - [InlineData(new[] { 1, 2, 3 }, new[] { 1, 2, 3, 4 }, false)] + [Test] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, true)] + [Arguments(new[] { 1, 2, 3 }, new[] { 1, 2, 3, 4 }, false)] public void StartsWithWithIntegers(IEnumerable first, IEnumerable second, bool expected) { using var f = first.AsTestingSequence(); @@ -14,10 +14,10 @@ public void StartsWithWithIntegers(IEnumerable first, IEnumerable seco Assert.Equal(expected, f.StartsWith(s)); } - [Theory] - [InlineData(new[] { '1', '2', '3' }, new[] { '1', '2' }, true)] - [InlineData(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, true)] - [InlineData(new[] { '1', '2', '3' }, new[] { '1', '2', '3', '4' }, false)] + [Test] + [Arguments(new[] { '1', '2', '3' }, new[] { '1', '2' }, true)] + [Arguments(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, true)] + [Arguments(new[] { '1', '2', '3' }, new[] { '1', '2', '3', '4' }, false)] public void StartsWithWithChars(IEnumerable first, IEnumerable second, bool expected) { using var f = first.AsTestingSequence(); @@ -26,10 +26,10 @@ public void StartsWithWithChars(IEnumerable first, IEnumerable secon Assert.Equal(expected, f.StartsWith(s)); } - [Theory] - [InlineData("123", "12", true)] - [InlineData("123", "123", true)] - [InlineData("123", "1234", false)] + [Test] + [Arguments("123", "12", true)] + [Arguments("123", "123", true)] + [Arguments("123", "1234", false)] public void StartsWithWithStrings(string first, string second, bool expected) { using var f = first.AsTestingSequence(); @@ -38,7 +38,7 @@ public void StartsWithWithStrings(string first, string second, bool expected) Assert.Equal(expected, f.StartsWith(s)); } - [Fact] + [Test] public void StartsWithReturnsTrueIfBothEmpty() { using var f = Array.Empty().AsTestingSequence(); @@ -47,7 +47,7 @@ public void StartsWithReturnsTrueIfBothEmpty() Assert.True(f.StartsWith(s)); } - [Fact] + [Test] public void StartsWithReturnsFalseIfOnlyFirstIsEmpty() { using var f = Array.Empty().AsTestingSequence(); @@ -56,9 +56,9 @@ public void StartsWithReturnsFalseIfOnlyFirstIsEmpty() Assert.False(f.StartsWith(s)); } - [Theory] - [InlineData("", "", true)] - [InlineData("1", "", true)] + [Test] + [Arguments("", "", true)] + [Arguments("1", "", true)] public void StartsWithReturnsTrueIfSecondIsEmpty(string first, string second, bool expected) { using var f = first.AsTestingSequence(); @@ -67,7 +67,7 @@ public void StartsWithReturnsTrueIfSecondIsEmpty(string first, string second, bo Assert.Equal(expected, f.StartsWith(s)); } - [Fact] + [Test] public void StartsWithUsesSpecifiedEqualityComparerOrDefault() { var first = Seq(1, 2, 3); @@ -78,7 +78,7 @@ public void StartsWithUsesSpecifiedEqualityComparerOrDefault() Assert.True(first.StartsWith(second, EqualityComparer.Create(delegate { return true; }))); } - [Fact] + [Test] public void StartsWithUsesCollectionsCountToAvoidUnnecessaryIteration() { using var first = new BreakingCollection(1, 2); diff --git a/Tests/SuperLinq.Test/SubsetTest.cs b/Tests/SuperLinq.Tests/SubsetTest.cs similarity index 84% rename from Tests/SuperLinq.Test/SubsetTest.cs rename to Tests/SuperLinq.Tests/SubsetTest.cs index 9107f18d9..54fcbad29 100644 --- a/Tests/SuperLinq.Test/SubsetTest.cs +++ b/Tests/SuperLinq.Tests/SubsetTest.cs @@ -1,4 +1,6 @@ -namespace Test; +using System.Diagnostics.CodeAnalysis; + +namespace SuperLinq.Tests; /// /// Tests of the Subset() family of extension methods. @@ -8,7 +10,7 @@ public sealed class SubsetTest /// /// Verify that Subsets() behaves in a lazy manner. /// - [Fact] + [Test] public void TestSubsetsIsLazy() { _ = new BreakingSequence().Subsets(); @@ -18,30 +20,30 @@ public void TestSubsetsIsLazy() /// /// Verify that negative subset sizes result in an exception. /// - [Fact] + [Test] public void TestNegativeSubsetSize() { _ = Assert.Throws(() => new BreakingSequence().Subsets(-5)); } - public static IEnumerable GetSubsetSequences() => + public static IEnumerable> GetSubsetSequences() => Enumerable.Range(1, 10) - .GetCollectionSequences() - .Select(x => new object?[] { x }); + .GetCollectionSequences(); /// /// Verify that requesting subsets larger than the original sequence length result in an exception. /// - [Theory] - [MemberData(nameof(GetSubsetSequences))] + [Test] + [MethodDataSource(typeof(TestExtensions), nameof(TestExtensions.GetCollectionSequences), Arguments = [new int[] { 1, 2, 3 }])] + [SuppressMessage("Usage", "TUnit0001:Invalid Data for Tests")] public void TestSubsetLargerThanSequence(IDisposableEnumerable seq) { using (seq) { _ = Assert.Throws(() => seq - .Subsets(15) + .Subsets(5) .Consume()); } } @@ -49,7 +51,7 @@ public void TestSubsetLargerThanSequence(IDisposableEnumerable seq) /// /// Verify that the only subset of an empty sequence is the empty sequence. /// - [Fact] + [Test] public void TestEmptySequenceSubsets() { using var sequence = TestingSequence.Of(); @@ -58,7 +60,7 @@ public void TestEmptySequenceSubsets() result.Single().AssertSequenceEqual(); } - [Fact] + [Test] public void TestSizeZeroSubsets() { using var sequence = TestingSequence.Of(1, 2, 3); @@ -70,8 +72,8 @@ public void TestSizeZeroSubsets() /// /// Verify that subsets are returned in increasing size, starting with the empty set. /// - [Theory] - [MemberData(nameof(GetSubsetSequences))] + [Test] + [MethodDataSource(nameof(GetSubsetSequences))] public void TestSubsetsInIncreasingOrder(IDisposableEnumerable seq) { using (seq) @@ -90,8 +92,8 @@ public void TestSubsetsInIncreasingOrder(IDisposableEnumerable seq) /// /// Verify that the number of subsets returned is correct, but don't verify the subset contents. /// - [Theory] - [MemberData(nameof(GetSubsetSequences))] + [Test] + [MethodDataSource(nameof(GetSubsetSequences))] public void TestAllSubsetsExpectedCount(IDisposableEnumerable seq) { using (seq) @@ -104,7 +106,7 @@ public void TestAllSubsetsExpectedCount(IDisposableEnumerable seq) /// /// Verify that the complete subset results for a known set are correct. /// - [Fact] + [Test] public void TestAllSubsetsExpectedResults() { using var sequence = Enumerable.Range(1, 4).AsTestingSequence(); @@ -123,22 +125,18 @@ public void TestAllSubsetsExpectedResults() expected.AssertSequenceEqual(actual); } - public static IEnumerable SubsetSizes() => + public static IEnumerable<(IDisposableEnumerable seq, int subsetSize)> SubsetSizes() => Enumerable.Range(1, 20) .SelectMany(size => Enumerable.Range(1, 20) .GetCollectionSequences() - .Select(seq => new object[] - { - seq, - size, - })); + .Select(seq => (seq, size))); /// /// Verify that the number of subsets for a given subset-size is correct. /// - [Theory] - [MemberData(nameof(SubsetSizes))] + [Test] + [MethodDataSource(nameof(SubsetSizes))] public void TestKSubsetExpectedCount(IDisposableEnumerable seq, int subsetSize) { using (seq) @@ -154,7 +152,7 @@ public void TestKSubsetExpectedCount(IDisposableEnumerable seq, int subsetS /// /// Verify that k-subsets of a given set are in the correct order and contain the correct elements. /// - [Fact] + [Test] public void TestKSubsetExpectedResult() { using var sequence = Enumerable.Range(1, 6).AsTestingSequence(); diff --git a/Tests/SuperLinq.Tests/SuperLinq.Tests.csproj b/Tests/SuperLinq.Tests/SuperLinq.Tests.csproj new file mode 100644 index 000000000..82c3efcc8 --- /dev/null +++ b/Tests/SuperLinq.Tests/SuperLinq.Tests.csproj @@ -0,0 +1,35 @@ + + + + net47;net8.0;net9.0 + + false + latest-recommended + + System.Runtime.CompilerServices.ModuleInitializerAttribute + + + + + + + + + + + + + + + $(DefineConstants);NO_INDEX + + + + + + + + + + + diff --git a/Tests/SuperLinq.Test/TagFirstLastTest.cs b/Tests/SuperLinq.Tests/TagFirstLastTest.cs similarity index 82% rename from Tests/SuperLinq.Test/TagFirstLastTest.cs rename to Tests/SuperLinq.Tests/TagFirstLastTest.cs index ccde80ac1..7a3643722 100644 --- a/Tests/SuperLinq.Test/TagFirstLastTest.cs +++ b/Tests/SuperLinq.Tests/TagFirstLastTest.cs @@ -1,23 +1,23 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class TagFirstLastTest { - [Fact] + [Test] public void TagFirstLastIsLazy() { _ = new BreakingSequence().TagFirstLast(); _ = new BreakingSequence().TagFirstLast(BreakingFunc.Of()); } - public static IEnumerable GetSourceSequences() => + public static IEnumerable<(IDisposableEnumerable seq, int n)> GetSourceSequences() => Enumerable.Range(0, 4) .SelectMany(n => Enumerable.Range(0, n) .GetListSequences() - .Select(x => new object[] { x, n })); + .Select(x => (x, n))); - [Theory] - [MemberData(nameof(GetSourceSequences))] + [Test] + [MethodDataSource(nameof(GetSourceSequences))] public void TagFirstLastVaryingLengths(IDisposableEnumerable seq, int n) { using (seq) @@ -29,7 +29,7 @@ public void TagFirstLastVaryingLengths(IDisposableEnumerable seq, int n) } } - [Fact] + [Test] public void TagFirstLastListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/TakeEveryTest.cs b/Tests/SuperLinq.Tests/TakeEveryTest.cs similarity index 93% rename from Tests/SuperLinq.Test/TakeEveryTest.cs rename to Tests/SuperLinq.Tests/TakeEveryTest.cs index 78f894b33..024e985fc 100644 --- a/Tests/SuperLinq.Test/TakeEveryTest.cs +++ b/Tests/SuperLinq.Tests/TakeEveryTest.cs @@ -1,28 +1,28 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class TakeEveryTest { - [Fact] + [Test] public void TakeEveryIsLazy() { _ = new BreakingSequence().TakeEvery(1); } - [Fact] + [Test] public void TakeEveryNegativeSkip() { _ = Assert.Throws(() => new BreakingSequence().TakeEvery(-1)); } - [Fact] + [Test] public void TakeEveryOutOfRangeZeroStep() { _ = Assert.Throws(() => new BreakingSequence().TakeEvery(0)); } - [Fact] + [Test] public void TakeEveryEmptySequence() { using var sequence = TestingSequence.Of(); @@ -31,7 +31,7 @@ public void TakeEveryEmptySequence() result.AssertSequenceEqual(); } - [Fact] + [Test] public void TakeEveryNonEmptySequence() { using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); @@ -40,7 +40,7 @@ public void TakeEveryNonEmptySequence() result.AssertSequenceEqual(1, 2, 3, 4, 5); } - [Fact] + [Test] public void TakeEveryOtherOnNonEmptySequence() { using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); @@ -49,7 +49,7 @@ public void TakeEveryOtherOnNonEmptySequence() result.AssertSequenceEqual(1, 3, 5); } - [Fact] + [Test] public void TakeEveryThirdOnNonEmptySequence() { using var sequence = Enumerable.Range(1, 5).AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/TakeTest.cs b/Tests/SuperLinq.Tests/TakeTest.cs similarity index 96% rename from Tests/SuperLinq.Test/TakeTest.cs rename to Tests/SuperLinq.Tests/TakeTest.cs index e2df85d02..bf9f6cfd2 100644 --- a/Tests/SuperLinq.Test/TakeTest.cs +++ b/Tests/SuperLinq.Tests/TakeTest.cs @@ -3,11 +3,11 @@ #if !NO_INDEX -namespace Test; +namespace SuperLinq.Tests; public sealed class TakeTest { - [Fact] + [Test] public void SameResultsRepeatCallsIntQuery() { var q = from x in new[] { 9999, 0, 888, -1, 66, -777, 1, 2, -12345 } @@ -22,7 +22,7 @@ where x > int.MinValue Assert.Equal(q.Take(^9..^0), q.Take(^9..^0)); } - [Fact] + [Test] public void SameResultsRepeatCallsIntQueryIList() { var q = (from x in new[] { 9999, 0, 888, -1, 66, -777, 1, 2, -12345 } @@ -37,7 +37,7 @@ where x > int.MinValue Assert.Equal(q.Take(^9..^0), q.Take(^9..^0)); } - [Fact] + [Test] public void SameResultsRepeatCallsStringQuery() { var q = from x in new[] { "!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", "" } @@ -52,7 +52,7 @@ public void SameResultsRepeatCallsStringQuery() Assert.Equal(q.Take(^7..^0), q.Take(^7..^0)); } - [Fact] + [Test] public void SameResultsRepeatCallsStringQueryIList() { var q = (from x in new[] { "!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", "" } @@ -67,7 +67,7 @@ public void SameResultsRepeatCallsStringQueryIList() Assert.Equal(q.Take(^7..^0), q.Take(^7..^0)); } - [Fact] + [Test] public void SourceEmptyCountPositive() { var source = Array.Empty(); @@ -79,7 +79,7 @@ public void SourceEmptyCountPositive() Assert.Empty(source.Take(^5..^0)); } - [Fact] + [Test] public void SourceEmptyCountPositiveNotIList() { var source = Enumerable.Range(0, 0); @@ -91,7 +91,7 @@ public void SourceEmptyCountPositiveNotIList() Assert.Empty(source.Take(^5..^0)); } - [Fact] + [Test] public void SourceNonEmptyCountNegative() { var source = new[] { 2, 5, 9, 1 }; @@ -100,7 +100,7 @@ public void SourceNonEmptyCountNegative() Assert.Empty(source.Take(^9..0)); } - [Fact] + [Test] public void SourceNonEmptyCountNegativeNotIList() { var source = Seq(2, 5, 9, 1); @@ -109,7 +109,7 @@ public void SourceNonEmptyCountNegativeNotIList() Assert.Empty(source.Take(^9..0)); } - [Fact] + [Test] public void SourceNonEmptyCountZero() { var source = new[] { 2, 5, 9, 1 }; @@ -121,7 +121,7 @@ public void SourceNonEmptyCountZero() Assert.Empty(source.Take(^4..^4)); } - [Fact] + [Test] public void SourceNonEmptyCountZeroNotIList() { var source = Seq(2, 5, 9, 1); @@ -133,7 +133,7 @@ public void SourceNonEmptyCountZeroNotIList() Assert.Empty(source.Take(^4..^4)); } - [Fact] + [Test] public void SourceNonEmptyCountOne() { var source = new[] { 2, 5, 9, 1 }; @@ -147,7 +147,7 @@ public void SourceNonEmptyCountOne() Assert.Equal(expected, source.Take(^4..^3)); } - [Fact] + [Test] public void SourceNonEmptyCountOneNotIList() { var source = Seq(2, 5, 9, 1); @@ -161,7 +161,7 @@ public void SourceNonEmptyCountOneNotIList() Assert.Equal(expected, source.Take(^4..^3)); } - [Fact] + [Test] public void SourceNonEmptyTakeAllExactly() { var source = new[] { 2, 5, 9, 1 }; @@ -174,7 +174,7 @@ public void SourceNonEmptyTakeAllExactly() Assert.Equal(source, source.Take(^source.Length..^0)); } - [Fact] + [Test] public void SourceNonEmptyTakeAllExactlyNotIList() { var source = Seq(2, 5, 9, 1); @@ -187,7 +187,7 @@ public void SourceNonEmptyTakeAllExactlyNotIList() Assert.Equal(source, source.Take(^source.Count()..^0)); } - [Fact] + [Test] public void SourceNonEmptyTakeAllButOne() { var source = new[] { 2, 5, 9, 1 }; @@ -201,7 +201,7 @@ public void SourceNonEmptyTakeAllButOne() Assert.Equal(expected, source.Take(^4..^1)); } - [Fact] + [Test] public void RunOnce() { var source = new[] { 2, 5, 9, 1 }; @@ -215,7 +215,7 @@ public void RunOnce() Assert.Equal(expected, source.Take(^4..^1)); } - [Fact] + [Test] public void SourceNonEmptyTakeAllButOneNotIList() { var source = Seq(2, 5, 9, 1); @@ -229,7 +229,7 @@ public void SourceNonEmptyTakeAllButOneNotIList() Assert.Equal(expected, source.Take(^4..^1)); } - [Fact] + [Test] public void SourceNonEmptyTakeExcessive() { var source = new int?[] { 2, 5, null, 9, 1 }; @@ -240,7 +240,7 @@ public void SourceNonEmptyTakeExcessive() Assert.Equal(source, source.Take(^(source.Length + 1)..(source.Length + 1))); } - [Fact] + [Test] public void SourceNonEmptyTakeExcessiveNotIList() { var source = Seq(2, 5, null, 9, 1); @@ -251,7 +251,7 @@ public void SourceNonEmptyTakeExcessiveNotIList() Assert.Equal(source, source.Take(^(source.Count() + 1)..(source.Count() + 1))); } - [Fact] + [Test] public void ThrowsOnNullSource() { int[] source = null!; @@ -263,7 +263,7 @@ public void ThrowsOnNullSource() _ = Assert.Throws("source", () => source.Take(^5..^0)); } - [Fact] + [Test] public void ForcedToEnumeratorDoesNotEnumerate() { var iterator1 = Enumerable.Range(0, 3).Take(2); @@ -289,7 +289,7 @@ public void ForcedToEnumeratorDoesNotEnumerate() } #pragma warning disable xUnit2013 // Do not use equality check to check for collection size. - [Fact] + [Test] public void Count() { Assert.Equal(2, Enumerable.Range(0, 3).Take(2).Count()); @@ -314,7 +314,7 @@ public void Count() } #pragma warning restore xUnit2013 // Do not use equality check to check for collection size. - [Fact] + [Test] public void ForcedToEnumeratorDoesntEnumerateIList() { var iterator1 = Enumerable.Range(0, 3).ToList().Take(2); @@ -339,7 +339,7 @@ public void ForcedToEnumeratorDoesntEnumerateIList() Assert.False(en5 is not null && en5.MoveNext()); } - [Fact] + [Test] public void FollowWithTake() { var source = new[] { 5, 6, 7, 8 }; @@ -352,7 +352,7 @@ public void FollowWithTake() Assert.Equal(expected, source.Take(^4..^0).Take(^4..^1).Take(^3..^1).Take(^2..^0)); } - [Fact] + [Test] public void FollowWithTakeNotIList() { var source = Enumerable.Range(5, 4); @@ -365,7 +365,7 @@ public void FollowWithTakeNotIList() Assert.Equal(expected, source.Take(^4..^0).Take(^4..^1).Take(^3..^1)); } - [Fact] + [Test] public void FollowWithSkip() { var source = new[] { 1, 2, 3, 4, 5, 6 }; @@ -378,7 +378,7 @@ public void FollowWithSkip() Assert.Equal(expected, source.Take(^6..^1).Skip(2).Skip(-4)); } - [Fact] + [Test] public void FollowWithSkipNotIList() { var source = Enumerable.Range(1, 6); @@ -391,7 +391,7 @@ public void FollowWithSkipNotIList() Assert.Equal(expected, source.Take(^6..^1).Skip(2).Skip(-4)); } - [Fact] + [Test] public void ElementAt() { var source = new[] { 1, 2, 3, 4, 5, 6 }; @@ -426,7 +426,7 @@ public void ElementAt() _ = Assert.Throws("index", () => taken4.ElementAt(3)); } - [Fact] + [Test] public void ElementAtNotIList() { var source = Seq(1, 2, 3, 4, 5, 6); @@ -461,7 +461,7 @@ public void ElementAtNotIList() _ = Assert.Throws("index", () => taken4.ElementAt(3)); } - [Fact] + [Test] public void ElementAtOrDefault() { var source = new[] { 1, 2, 3, 4, 5, 6 }; @@ -496,7 +496,7 @@ public void ElementAtOrDefault() Assert.Equal(0, taken4.ElementAtOrDefault(3)); } - [Fact] + [Test] public void ElementAtOrDefaultNotIList() { var source = Seq(1, 2, 3, 4, 5, 6); @@ -531,7 +531,7 @@ public void ElementAtOrDefaultNotIList() Assert.Equal(0, taken4.ElementAtOrDefault(3)); } - [Fact] + [Test] public void First() { var source = new[] { 1, 2, 3, 4, 5 }; @@ -566,7 +566,7 @@ public void First() _ = Assert.Throws(() => source.Skip(5).Take(^10..^0).First()); } - [Fact] + [Test] public void FirstNotIList() { var source = Seq(1, 2, 3, 4, 5); @@ -601,7 +601,7 @@ public void FirstNotIList() _ = Assert.Throws(() => source.Skip(5).Take(^10..^0).First()); } - [Fact] + [Test] public void FirstOrDefault() { var source = new[] { 1, 2, 3, 4, 5 }; @@ -636,7 +636,7 @@ public void FirstOrDefault() Assert.Equal(0, source.Skip(5).Take(^10..^0).FirstOrDefault()); } - [Fact] + [Test] public void FirstOrDefaultNotIList() { var source = Seq(1, 2, 3, 4, 5); @@ -671,7 +671,7 @@ public void FirstOrDefaultNotIList() Assert.Equal(0, source.Skip(5).Take(^10..^0).FirstOrDefault()); } - [Fact] + [Test] public void Last() { var source = new[] { 1, 2, 3, 4, 5 }; @@ -706,7 +706,7 @@ public void Last() _ = Assert.Throws(() => Array.Empty().Take(^40..^0).Last()); } - [Fact] + [Test] public void LastNotIList() { var source = Seq(1, 2, 3, 4, 5); @@ -741,7 +741,7 @@ public void LastNotIList() _ = Assert.Throws(() => Enumerable.Empty().Take(^40..^0).Last()); } - [Fact] + [Test] public void LastOrDefault() { var source = new[] { 1, 2, 3, 4, 5 }; @@ -776,7 +776,7 @@ public void LastOrDefault() Assert.Equal(0, Array.Empty().Take(^40..^0).LastOrDefault()); } - [Fact] + [Test] public void LastOrDefaultNotIList() { var source = Seq(1, 2, 3, 4, 5); @@ -811,7 +811,7 @@ public void LastOrDefaultNotIList() Assert.Equal(0, Enumerable.Empty().Take(^40..^0).LastOrDefault()); } - [Fact] + [Test] public void TakeCanOnlyBeOneList() { var source = new[] { 2, 4, 6, 8, 10 }; @@ -841,7 +841,7 @@ public void TakeCanOnlyBeOneList() Assert.Equal([2], source.Take(^5..^2).Take(^4..^2)); } - [Fact] + [Test] public void TakeCanOnlyBeOneNotList() { var source = Seq(2, 4, 6, 8, 10); @@ -871,7 +871,7 @@ public void TakeCanOnlyBeOneNotList() Assert.Equal([2], source.Take(^5..^2).Take(^4..^2)); } - [Fact] + [Test] public void RepeatEnumerating() { var source = new[] { 1, 2, 3, 4, 5 }; @@ -891,7 +891,7 @@ public void RepeatEnumerating() Assert.Equal(taken5, taken5); } - [Fact] + [Test] public void RepeatEnumeratingNotList() { var source = Seq(1, 2, 3, 4, 5); @@ -911,7 +911,7 @@ public void RepeatEnumeratingNotList() Assert.Equal(taken5, taken5); } - [Fact] + [Test] public void LazyOverflowRegression() { var range = Enumerable.Range(1, 100); @@ -947,17 +947,17 @@ public void LazyOverflowRegression() Assert.Equal(Enumerable.Range(43, 100 - 42), taken5.ToList()); } - [Theory] - [InlineData(0, 0, 0)] - [InlineData(1, 1, 1)] - [InlineData(0, int.MaxValue, 100)] - [InlineData(int.MaxValue, 0, 0)] - [InlineData(0xffff, 1, 0)] - [InlineData(1, 0xffff, 99)] - [InlineData(int.MaxValue, int.MaxValue, 0)] - [InlineData(1, int.MaxValue, 99)] // Regression test: The max index is precisely int.MaxValue. - [InlineData(0, 100, 100)] - [InlineData(10, 100, 90)] + [Test] + [Arguments(0, 0, 0)] + [Arguments(1, 1, 1)] + [Arguments(0, int.MaxValue, 100)] + [Arguments(int.MaxValue, 0, 0)] + [Arguments(0xffff, 1, 0)] + [Arguments(1, 0xffff, 99)] + [Arguments(int.MaxValue, int.MaxValue, 0)] + [Arguments(1, int.MaxValue, 99)] // Regression test: The max index is precisely int.MaxValue. + [Arguments(0, 100, 100)] + [Arguments(10, 100, 90)] public void CountOfLazySkipTakeChain(int skip, int take, int expected) { const int TotalCount = 100; @@ -998,13 +998,13 @@ public void CountOfLazySkipTakeChain(int skip, int take, int expected) Assert.Equal(expected, partition5.Select(SuperEnumerable.Identity).ToArray().Length); } - [Theory] - [InlineData(new[] { 1, 2, 3, 4 }, 1, 3, 2, 4)] - [InlineData(new[] { 1 }, 0, 1, 1, 1)] - [InlineData(new[] { 1, 2, 3, 5, 8, 13 }, 1, int.MaxValue, 2, 13)] // Regression test: The max index is precisely int.MaxValue. - [InlineData(new[] { 1, 2, 3, 5, 8, 13 }, 0, 2, 1, 2)] - [InlineData(new[] { 1, 2, 3, 5, 8, 13 }, 500, 2, 0, 0)] - [InlineData(new int[] { }, 10, 8, 0, 0)] + [Test] + [Arguments(new[] { 1, 2, 3, 4 }, 1, 3, 2, 4)] + [Arguments(new[] { 1 }, 0, 1, 1, 1)] + [Arguments(new[] { 1, 2, 3, 5, 8, 13 }, 1, int.MaxValue, 2, 13)] // Regression test: The max index is precisely int.MaxValue. + [Arguments(new[] { 1, 2, 3, 5, 8, 13 }, 0, 2, 1, 2)] + [Arguments(new[] { 1, 2, 3, 5, 8, 13 }, 500, 2, 0, 0)] + [Arguments(new int[] { }, 10, 8, 0, 0)] public void FirstAndLastOfLazySkipTakeChain(int[] source, int skip, int take, int first, int last) { var partition1 = ForceNotCollection(source).Skip(skip).Take(take); @@ -1053,11 +1053,11 @@ public void FirstAndLastOfLazySkipTakeChain(int[] source, int skip, int take, in Assert.Equal(last, partition5.ElementAtOrDefault(partition5.Count() - 1)); } - [Theory] - [InlineData(new[] { 1, 2, 3, 4, 5 }, 1, 3, new[] { -1, 0, 1, 2 }, new[] { 0, 2, 3, 4 })] - [InlineData(new[] { 0xfefe, 7000, 123 }, 0, 3, new[] { -1, 0, 1, 2 }, new[] { 0, 0xfefe, 7000, 123 })] - [InlineData(new[] { 0xfefe }, 100, 100, new[] { -1, 0, 1, 2 }, new[] { 0, 0, 0, 0 })] - [InlineData(new[] { 0xfefe, 123, 456, 7890, 5555, 55 }, 1, 10, new[] { -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }, new[] { 0, 123, 456, 7890, 5555, 55, 0, 0, 0, 0, 0, 0, 0 })] + [Test] + [Arguments(new[] { 1, 2, 3, 4, 5 }, 1, 3, new[] { -1, 0, 1, 2 }, new[] { 0, 2, 3, 4 })] + [Arguments(new[] { 0xfefe, 7000, 123 }, 0, 3, new[] { -1, 0, 1, 2 }, new[] { 0, 0xfefe, 7000, 123 })] + [Arguments(new[] { 0xfefe }, 100, 100, new[] { -1, 0, 1, 2 }, new[] { 0, 0, 0, 0 })] + [Arguments(new[] { 0xfefe, 123, 456, 7890, 5555, 55 }, 1, 10, new[] { -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }, new[] { 0, 123, 456, 7890, 5555, 55, 0, 0, 0, 0, 0, 0, 0 })] public void ElementAtOfLazySkipTakeChain(int[] source, int skip, int take, int[] indices, int[] expectedValues) { var partition1 = ForceNotCollection(source).Skip(skip).Take(take); @@ -1093,7 +1093,7 @@ public void ElementAtOfLazySkipTakeChain(int[] source, int skip, int take, int[] Assert.Equal(expectedValues[i], partition5.ElementAtOrDefault(indices[i])); } - [Fact] + [Test] public void OutOfBoundNoException() { static int[] Source() => [1, 2, 3, 4, 5]; @@ -1130,7 +1130,7 @@ public void OutOfBoundNoException() Assert.Empty(Source().Take(^int.MaxValue..^int.MaxValue)); } - [Fact] + [Test] public void OutOfBoundNoExceptionNotList() { var source = new[] { 1, 2, 3, 4, 5 }; @@ -1167,7 +1167,7 @@ public void OutOfBoundNoExceptionNotList() Assert.Empty(ForceNotCollection(source).Take(^int.MaxValue..^int.MaxValue)); } - [Fact] + [Test] public void MutableSource() { var source1 = new List() { 0, 1, 2, 3, 4 }; @@ -1195,7 +1195,7 @@ public void MutableSource() Assert.Equal([1, 2, -1], query4); } - [Fact] + [Test] public void MutableSourceNotList() { var source1 = new List() { 0, 1, 2, 3, 4 }; @@ -1223,7 +1223,7 @@ public void MutableSourceNotList() Assert.Equal([1, 2, -1], query4); } - [Fact] + [Test] public void NonEmptySourceConsistencyWithCountable() { static int[] Source() => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1269,7 +1269,7 @@ public void NonEmptySourceConsistencyWithCountable() Assert.Equal(Source()[^6..^6], Source().Take(^6..^6)); } - [Fact] + [Test] public void NonEmptySourceConsistencyWithCountableNotList() { int[] source = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1315,7 +1315,7 @@ public void NonEmptySourceConsistencyWithCountableNotList() Assert.Equal(source[^6..^6], ForceNotCollection(source).Take(^6..^6)); } - [Fact] + [Test] public void NonEmptySourceDoNotThrowException() { static int[] Source() => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1326,7 +1326,7 @@ public void NonEmptySourceDoNotThrowException() Assert.Empty(Source().Take(^6..^7)); } - [Fact] + [Test] public void NonEmptySourceDoNotThrowExceptionNotList() { int[] source = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1337,7 +1337,7 @@ public void NonEmptySourceDoNotThrowExceptionNotList() Assert.Empty(ForceNotCollection(source).Take(^6..^7)); } - [Fact] + [Test] public void EmptySourceDoNotThrowException() { static int[] Source() => []; @@ -1389,7 +1389,7 @@ public void EmptySourceDoNotThrowException() Assert.Empty(Source().Take(^6..^7)); } - [Fact] + [Test] public void EmptySourceDoNotThrowExceptionNotList() { var source = Array.Empty(); diff --git a/Tests/SuperLinq.Test/TakeUntilTest.cs b/Tests/SuperLinq.Tests/TakeUntilTest.cs similarity index 93% rename from Tests/SuperLinq.Test/TakeUntilTest.cs rename to Tests/SuperLinq.Tests/TakeUntilTest.cs index 7c14e71b8..47404a204 100644 --- a/Tests/SuperLinq.Test/TakeUntilTest.cs +++ b/Tests/SuperLinq.Tests/TakeUntilTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class TakeUntilTest { - [Fact] + [Test] public void TakeUntilEvaluatesSourceLazily() { _ = new BreakingSequence().TakeUntil(x => x.Length == 0); } - [Fact] + [Test] public void TakeUntilPredicateNeverFalse() { using var sequence = Enumerable.Range(0, 5).AsTestingSequence(); @@ -17,7 +17,7 @@ public void TakeUntilPredicateNeverFalse() .AssertSequenceEqual(0); } - [Fact] + [Test] public void TakeUntilPredicateNeverTrue() { using var sequence = Enumerable.Range(0, 5).AsTestingSequence(); @@ -26,7 +26,7 @@ public void TakeUntilPredicateNeverTrue() .AssertSequenceEqual(Enumerable.Range(0, 5)); } - [Fact] + [Test] public void TakeUntilPredicateBecomesTrueHalfWay() { using var sequence = Enumerable.Range(0, 5).AsTestingSequence(); @@ -35,7 +35,7 @@ public void TakeUntilPredicateBecomesTrueHalfWay() .AssertSequenceEqual(0, 1, 2); } - [Fact] + [Test] public void TakeUntilEvaluatesPredicateLazily() { // Predicate would explode at x == 0, but we never need to evaluate it due to the Take call. diff --git a/Tests/SuperLinq.Test/TestException.cs b/Tests/SuperLinq.Tests/TestException.cs similarity index 79% rename from Tests/SuperLinq.Test/TestException.cs rename to Tests/SuperLinq.Tests/TestException.cs index 6d1fa192d..ed4b12a7a 100644 --- a/Tests/SuperLinq.Test/TestException.cs +++ b/Tests/SuperLinq.Tests/TestException.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Reserved for use within tests. diff --git a/Tests/SuperLinq.Test/TestExtensions.cs b/Tests/SuperLinq.Tests/TestExtensions.cs similarity index 80% rename from Tests/SuperLinq.Test/TestExtensions.cs rename to Tests/SuperLinq.Tests/TestExtensions.cs index 419dd5d7a..14f277320 100644 --- a/Tests/SuperLinq.Test/TestExtensions.cs +++ b/Tests/SuperLinq.Tests/TestExtensions.cs @@ -1,4 +1,4 @@ -namespace Test; +namespace SuperLinq.Tests; public enum SourceKind { @@ -6,7 +6,7 @@ public enum SourceKind BreakingCollection, } -internal static partial class TestExtensions +public static partial class TestExtensions { #region Sequences internal static IEnumerable Seq(params T[] values) => values; @@ -17,6 +17,18 @@ public static IEnumerable SeqExceptionAt(int index) => .Select(i => Func(() => i)) .Concat([BreakingFunc.Of()]) .ToArray()); + + public static IEnumerable> GetEmptySequences() => + Enumerable.Empty() + .GetBreakingCollectionSequences(); + + public static IEnumerable> GetSingleElementSequences() => + Seq(1) + .GetBreakingCollectionSequences(); + + public static IEnumerable> GetThreeElementSequences() => + Seq(1, 2, 3) + .GetBreakingCollectionSequences(); #endregion #region Sequence Content Validation @@ -109,7 +121,7 @@ internal static void AssertListElementChecking(this IEnumerable result, in #endregion #region Testing Sequence Generation - internal static IEnumerable> GetTestingSequence( + public static IEnumerable> GetTestingSequence( this IEnumerable input, int maxEnumerations = 1 ) @@ -118,28 +130,28 @@ internal static IEnumerable> GetTestingSequence( yield return input.AsTestingSequence(maxEnumerations: maxEnumerations); } - internal static IEnumerable> GetCollectionSequences(this IEnumerable input) + public static IEnumerable> GetCollectionSequences(this IEnumerable input) { // UI will consume one enumeration yield return input.AsTestingSequence(); yield return input.AsTestingCollection(); } - internal static IEnumerable> GetBreakingCollectionSequences(this IEnumerable input) + public static IEnumerable> GetBreakingCollectionSequences(this IEnumerable input) { // UI will consume one enumeration yield return input.AsTestingSequence(); yield return input.AsBreakingCollection(); } - internal static IEnumerable> GetListSequences(this IEnumerable input) + public static IEnumerable> GetListSequences(this IEnumerable input) { // UI will consume one enumeration yield return input.AsTestingSequence(); yield return new BreakingList(input); } - internal static IEnumerable> GetAllSequences(this IEnumerable input) + public static IEnumerable> GetAllSequences(this IEnumerable input) { // UI will consume one enumeration yield return input.AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/TestingCollection.cs b/Tests/SuperLinq.Tests/TestingCollection.cs similarity index 94% rename from Tests/SuperLinq.Test/TestingCollection.cs rename to Tests/SuperLinq.Tests/TestingCollection.cs index d2272cc55..36e846c5a 100644 --- a/Tests/SuperLinq.Test/TestingCollection.cs +++ b/Tests/SuperLinq.Tests/TestingCollection.cs @@ -1,6 +1,6 @@ -using static Test.TestingSequence; +using static SuperLinq.Tests.TestingSequence; -namespace Test; +namespace SuperLinq.Tests; internal static class TestingCollection { diff --git a/Tests/SuperLinq.Test/TestingSequence.cs b/Tests/SuperLinq.Tests/TestingSequence.cs similarity index 98% rename from Tests/SuperLinq.Test/TestingSequence.cs rename to Tests/SuperLinq.Tests/TestingSequence.cs index a007dbc93..ea1beeaa9 100644 --- a/Tests/SuperLinq.Test/TestingSequence.cs +++ b/Tests/SuperLinq.Tests/TestingSequence.cs @@ -1,9 +1,9 @@ using System.Collections; using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; -using static Test.TestingSequence; +using static SuperLinq.Tests.TestingSequence; -namespace Test; +namespace SuperLinq.Tests; internal static class TestingSequence { @@ -125,7 +125,7 @@ public IEnumerator GetEnumerator() public sealed class TestingSequenceTest { - [Fact] + [Test] public void TestingSequencePublicPropertiesTest() { using var sequence = Of(1, 2, 3, 4); @@ -147,7 +147,7 @@ public void TestingSequencePublicPropertiesTest() Assert.True(sequence.IsDisposed); } - [Fact] + [Test] public void TestingSequenceShouldValidateDisposal() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -166,7 +166,7 @@ static void Act() AssertSequenceBehavior(Act, ExpectedDisposal); } - [Fact] + [Test] public void TestingSequenceShouldValidateNumberOfUsages() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -190,7 +190,7 @@ static void Act() AssertSequenceBehavior(Act, TooManyEnumerations); } - [Fact] + [Test] public void TestingSequenceShouldValidateDisposeOnDisposedSequence() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -211,7 +211,7 @@ static void Act() AssertSequenceBehavior(Act, TooManyDisposals); } - [Fact] + [Test] public void TestingSequenceShouldValidateMoveNextOnDisposedSequence() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -232,7 +232,7 @@ static void Act() AssertSequenceBehavior(Act, MoveNextPostDisposal); } - [Fact] + [Test] public void TestingSequenceShouldValidateMoveNextOnCompletedSequence() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -253,7 +253,7 @@ static void Act() AssertSequenceBehavior(Act, MoveNextPostEnumeration); } - [Fact] + [Test] public void TestingSequenceShouldValidateCurrentOnDisposedSequence() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -272,7 +272,7 @@ static void Act() AssertSequenceBehavior(Act, CurrentPostDisposal); } - [Fact] + [Test] public void TestingSequenceShouldValidateCurrentOnEndedSequence() { static IEnumerable InvalidUsage(IEnumerable enumerable) @@ -293,7 +293,7 @@ static void Act() AssertSequenceBehavior(Act, CurrentPostEnumeration); } - [Fact] + [Test] public void TestingSequenceShouldValidateSimultaneousEnumeration() { static IEnumerable InvalidUsage(IEnumerable enumerable) diff --git a/Tests/SuperLinq.Test/ThrowTest.cs b/Tests/SuperLinq.Tests/ThrowTest.cs similarity index 85% rename from Tests/SuperLinq.Test/ThrowTest.cs rename to Tests/SuperLinq.Tests/ThrowTest.cs index bbe5d068d..609d47eec 100644 --- a/Tests/SuperLinq.Test/ThrowTest.cs +++ b/Tests/SuperLinq.Tests/ThrowTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ThrowTest { - [Fact] + [Test] public void ThrowIsLazy() { _ = SuperEnumerable.Throw(new TestException()); } - [Fact] + [Test] public void ThrowBehavior() { var seq = SuperEnumerable.Throw(new TestException()); diff --git a/Tests/SuperLinq.Test/ToArrayByIndexTest.cs b/Tests/SuperLinq.Tests/ToArrayByIndexTest.cs similarity index 75% rename from Tests/SuperLinq.Test/ToArrayByIndexTest.cs rename to Tests/SuperLinq.Tests/ToArrayByIndexTest.cs index 90483f0c1..82dc2db58 100644 --- a/Tests/SuperLinq.Test/ToArrayByIndexTest.cs +++ b/Tests/SuperLinq.Tests/ToArrayByIndexTest.cs @@ -1,24 +1,24 @@ using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; public sealed class ToArrayByIndexTest { - [Theory] - [InlineData(false, new int[0])] - [InlineData(false, new[] { 5 })] - [InlineData(false, new[] { 1, 5 })] - [InlineData(false, new[] { 0, 9 })] - [InlineData(false, new[] { 0, 5, 9 })] - [InlineData(false, new[] { 2, 3, 5, 9 })] - [InlineData(false, new[] { 5, 2, 9, 3 })] - [InlineData(true, new int[0])] - [InlineData(true, new[] { 5 })] - [InlineData(true, new[] { 1, 5 })] - [InlineData(true, new[] { 0, 9 })] - [InlineData(true, new[] { 0, 5, 9 })] - [InlineData(true, new[] { 2, 3, 5, 9 })] - [InlineData(true, new[] { 5, 2, 9, 3 })] + [Test] + [Arguments(false, new int[0])] + [Arguments(false, new[] { 5 })] + [Arguments(false, new[] { 1, 5 })] + [Arguments(false, new[] { 0, 9 })] + [Arguments(false, new[] { 0, 5, 9 })] + [Arguments(false, new[] { 2, 3, 5, 9 })] + [Arguments(false, new[] { 5, 2, 9, 3 })] + [Arguments(true, new int[0])] + [Arguments(true, new[] { 5 })] + [Arguments(true, new[] { 1, 5 })] + [Arguments(true, new[] { 0, 9 })] + [Arguments(true, new[] { 0, 5, 9 })] + [Arguments(true, new[] { 2, 3, 5, 9 })] + [Arguments(true, new[] { 5, 2, 9, 3 })] [SuppressMessage("Style", "IDE0305:Simplify collection initialization")] public void ToArrayByIndex(bool withLength, int[] indices) { @@ -39,7 +39,7 @@ public void ToArrayByIndex(bool withLength, int[] indices) expected.Select(x => x is null ? null : new { Index = x.Value })); } - [Fact] + [Test] public void ToArrayByIndexWithBadIndexSelectorThrows() { _ = Assert.Throws(() => @@ -49,9 +49,9 @@ public void ToArrayByIndexWithBadIndexSelectorThrows() Seq(42).ToArrayByIndex(_ => -1, BreakingFunc.Of())); } - [Theory] - [InlineData(10, -1)] - [InlineData(10, 10)] + [Test] + [Arguments(10, -1)] + [Arguments(10, 10)] public void ToArrayByIndexWithLengthWithBadIndexSelectorThrows(int length, int badIndex) { _ = Assert.Throws(() => @@ -61,7 +61,7 @@ public void ToArrayByIndexWithLengthWithBadIndexSelectorThrows(int length, int b Seq(42).ToArrayByIndex(length, _ => badIndex, BreakingFunc.Of())); } - [Fact] + [Test] public void ToArrayByIndexOverwritesAtSameIndex() { var a = new { Index = 2 }; diff --git a/Tests/SuperLinq.Test/ToDataTableTest.cs b/Tests/SuperLinq.Tests/ToDataTableTest.cs similarity index 97% rename from Tests/SuperLinq.Test/ToDataTableTest.cs rename to Tests/SuperLinq.Tests/ToDataTableTest.cs index 4b7633fca..201fe470b 100644 --- a/Tests/SuperLinq.Test/ToDataTableTest.cs +++ b/Tests/SuperLinq.Tests/ToDataTableTest.cs @@ -2,7 +2,7 @@ using System.Data; using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; [SuppressMessage("Design", "MA0150:Do not call the default object.ToString explicitly")] public sealed class ToDataTableTest @@ -28,7 +28,7 @@ public object this[int index] .Select(i => new TestObject(i)) .ToArray(); - [Fact] + [Test] public void ToDataTableTableWithWrongColumnNames() { using var dt = new DataTable(); @@ -39,7 +39,7 @@ public void ToDataTableTableWithWrongColumnNames() xs.ToDataTable(dt)); } - [Fact] + [Test] public void ToDataTableTableWithWrongColumnDataType() { using var dt = new DataTable(); @@ -50,7 +50,7 @@ public void ToDataTableTableWithWrongColumnDataType() xs.ToDataTable(dt, t => t.AString)); } - [Fact] + [Test] public void ToDataTableMemberExpressionMethod() { using var xs = _testObjects.AsTestingSequence(); @@ -58,7 +58,7 @@ public void ToDataTableMemberExpressionMethod() xs.ToDataTable(t => t.ToString()!)); } - [Fact] + [Test] public void ToDataTableMemberExpressionNonMember() { using var xs = _testObjects.AsTestingSequence(); @@ -66,7 +66,7 @@ public void ToDataTableMemberExpressionNonMember() xs.ToDataTable(t => t.ToString()!.Length)); } - [Fact] + [Test] public void ToDataTableMemberExpressionIndexer() { using var xs = _testObjects.AsTestingSequence(); @@ -74,7 +74,7 @@ public void ToDataTableMemberExpressionIndexer() xs.ToDataTable(t => t[0])); } - [Fact] + [Test] public void ToDataTableSchemaInDeclarationOrder() { using var xs = _testObjects.AsTestingSequence(); @@ -98,7 +98,7 @@ public void ToDataTableSchemaInDeclarationOrder() Assert.Equal(4, dt.Columns.Count); } - [Fact] + [Test] public void ToDataTableContainsAllElements() { using var xs = _testObjects.AsTestingSequence(); @@ -106,7 +106,7 @@ public void ToDataTableContainsAllElements() Assert.Equal(_testObjects.Length, dt.Rows.Count); } - [Fact] + [Test] public void ToDataTableWithExpression() { using var xs = _testObjects.AsTestingSequence(); @@ -118,7 +118,7 @@ public void ToDataTableWithExpression() _ = Assert.Single(dt.Columns); } - [Fact] + [Test] public void ToDataTableWithSchema() { using var dt = new DataTable(); @@ -151,7 +151,7 @@ private readonly struct Point public Point(int x, int y) : this() => (X, Y) = (x, y); } - [Fact] + [Test] public void ToDataTableIgnoresStaticMembers() { using var xs = new[] { new Point(12, 34) }.AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/ToDelimitedStringTest.cs b/Tests/SuperLinq.Tests/ToDelimitedStringTest.cs similarity index 92% rename from Tests/SuperLinq.Test/ToDelimitedStringTest.cs rename to Tests/SuperLinq.Tests/ToDelimitedStringTest.cs index aebff03ae..208f47269 100644 --- a/Tests/SuperLinq.Test/ToDelimitedStringTest.cs +++ b/Tests/SuperLinq.Tests/ToDelimitedStringTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ToDelimitedStringTest { - [Fact] + [Test] public void ToDelimitedStringWithNonEmptySequenceAndDelimiter() { using var seq = TestingSequence.Of(1, 2, 3); @@ -10,7 +10,7 @@ public void ToDelimitedStringWithNonEmptySequenceAndDelimiter() Assert.Equal("1-2-3", result); } - [Fact] + [Test] public void ToDelimitedStringWithNonEmptySequenceContainingNulls() { using var seq = TestingSequence.Of(1, null, "foo", true); @@ -18,7 +18,7 @@ public void ToDelimitedStringWithNonEmptySequenceContainingNulls() Assert.Equal("1,,foo,True", result); } - [Fact] + [Test] public void ToDelimitedStringWithNonEmptySequenceContainingNullsAtStart() { using var seq = TestingSequence.Of(null, null, "foo"); diff --git a/Tests/SuperLinq.Test/ToDictionaryTest.cs b/Tests/SuperLinq.Tests/ToDictionaryTest.cs similarity index 96% rename from Tests/SuperLinq.Test/ToDictionaryTest.cs rename to Tests/SuperLinq.Tests/ToDictionaryTest.cs index 202a13404..7c6e146df 100644 --- a/Tests/SuperLinq.Test/ToDictionaryTest.cs +++ b/Tests/SuperLinq.Tests/ToDictionaryTest.cs @@ -1,9 +1,9 @@ -namespace Test; +namespace SuperLinq.Tests; [Obsolete("References `ToDictionary` which is obsolete in net8+")] public sealed class ToDictionaryTest { - [Fact] + [Test] public void ToDictionaryWithKeyValuePairs() { using var pairs = TestingSequence.Of( @@ -18,7 +18,7 @@ public void ToDictionaryWithKeyValuePairs() Assert.Equal(789, dict["baz"]); } - [Fact] + [Test] public void ToDictionaryWithCouples() { using var pairs = TestingSequence.Of( @@ -33,7 +33,7 @@ public void ToDictionaryWithCouples() Assert.Equal(789, dict["baz"]); } - [Fact] + [Test] public void ToDictionaryWithKeyValuePairsWithComparer() { using var pairs = TestingSequence.Of( @@ -48,7 +48,7 @@ public void ToDictionaryWithKeyValuePairsWithComparer() Assert.Equal(789, dict["BAZ"]); } - [Fact] + [Test] public void ToDictionaryWithCouplesWithComparer() { using var pairs = TestingSequence.Of( diff --git a/Tests/SuperLinq.Test/ToLookupTest.cs b/Tests/SuperLinq.Tests/ToLookupTest.cs similarity index 96% rename from Tests/SuperLinq.Test/ToLookupTest.cs rename to Tests/SuperLinq.Tests/ToLookupTest.cs index 91c6bc1a8..06a179c81 100644 --- a/Tests/SuperLinq.Test/ToLookupTest.cs +++ b/Tests/SuperLinq.Tests/ToLookupTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ToLookupTest { - [Fact] + [Test] public void ToLookupWithKeyValuePairs() { var pairs = new[] @@ -23,7 +23,7 @@ public void ToLookupWithKeyValuePairs() Assert.Equal([4, 5, 6], dict["baz"]); } - [Fact] + [Test] public void ToLookupWithCouples() { var pairs = new[] @@ -44,7 +44,7 @@ public void ToLookupWithCouples() Assert.Equal([4, 5, 6], dict["baz"]); } - [Fact] + [Test] public void ToLookupWithKeyValuePairsWithComparer() { var pairs = new[] @@ -65,7 +65,7 @@ public void ToLookupWithKeyValuePairsWithComparer() Assert.Equal([4, 5, 6], dict["BAZ"]); } - [Fact] + [Test] public void ToLookupWithCouplesWithComparer() { var pairs = new[] diff --git a/Tests/SuperLinq.Test/TransposeTest.cs b/Tests/SuperLinq.Tests/TransposeTest.cs similarity index 97% rename from Tests/SuperLinq.Test/TransposeTest.cs rename to Tests/SuperLinq.Tests/TransposeTest.cs index ab9ca2d2d..7fc8edf9a 100644 --- a/Tests/SuperLinq.Test/TransposeTest.cs +++ b/Tests/SuperLinq.Tests/TransposeTest.cs @@ -1,14 +1,14 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class TransposeTest { - [Fact] + [Test] public void TransposeIsLazy() { _ = new BreakingSequence>().Transpose(); } - [Fact] + [Test] public void TransposeWithOneNullRow() { using var seq1 = TestingSequence.Of(10, 11); @@ -20,7 +20,7 @@ public void TransposeWithOneNullRow() matrix!.Transpose().FirstOrDefault()); } - [Fact] + [Test] public void TransposeWithRowsOfSameLength() { var expectations = new int[][] @@ -39,7 +39,7 @@ public void TransposeWithRowsOfSameLength() AssertMatrix(expectations, matrix.Transpose()); } - [Fact] + [Test] public void TransposeWithRowsOfDifferentLengths() { var expectations = new int[][] @@ -58,7 +58,7 @@ public void TransposeWithRowsOfDifferentLengths() AssertMatrix(expectations, matrix.Transpose()); } - [Fact] + [Test] public void TransposeMaintainsCornerElements() { var sequences = new List>() @@ -77,7 +77,7 @@ public void TransposeMaintainsCornerElements() sequences.VerifySequences(); } - [Fact] + [Test] public void TransposeWithAllRowsAsInfiniteSequences() { var sequences = new List>(); @@ -103,7 +103,7 @@ public void TransposeWithAllRowsAsInfiniteSequences() sequences.VerifySequences(); } - [Fact] + [Test] public void TransposeWithSomeRowsAsInfiniteSequences() { var sequences = new List>(); @@ -130,7 +130,7 @@ public void TransposeWithSomeRowsAsInfiniteSequences() sequences.VerifySequences(); } - [Fact] + [Test] public void TransposeColumnTraversalOrderIsIrrelevant() { var sequences = new List>() @@ -150,7 +150,7 @@ public void TransposeColumnTraversalOrderIsIrrelevant() sequences.VerifySequences(); } - [Fact] + [Test] public void TransposeConsumesRowsLazily() { var sequences = new List>() @@ -170,7 +170,7 @@ public void TransposeConsumesRowsLazily() sequences.VerifySequences(); } - [Fact] + [Test] public void TransposeWithErroneousRowDisposesRowIterators() { using var row1 = TestingSequence.Of(10, 11); diff --git a/Tests/SuperLinq.Test/TraverseTest.cs b/Tests/SuperLinq.Tests/TraverseTest.cs similarity index 96% rename from Tests/SuperLinq.Test/TraverseTest.cs rename to Tests/SuperLinq.Tests/TraverseTest.cs index 2a23b585a..057015a3d 100644 --- a/Tests/SuperLinq.Test/TraverseTest.cs +++ b/Tests/SuperLinq.Tests/TraverseTest.cs @@ -1,20 +1,20 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class TraverseTest { - [Fact] + [Test] public void TraverseDepthFirstIsStreaming() { _ = SuperEnumerable.TraverseDepthFirst(new object(), o => new BreakingSequence()); } - [Fact] + [Test] public void TraverseBreadthFirstIsStreaming() { _ = SuperEnumerable.TraverseBreadthFirst(new object(), o => new BreakingSequence()); } - [Fact] + [Test] public void TraverseDepthFirstPreservesChildrenOrder() { using var root = Enumerable.Range(1, 10).AsTestingSequence(); @@ -23,7 +23,7 @@ public void TraverseDepthFirstPreservesChildrenOrder() res.AssertSequenceEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } - [Fact] + [Test] public void TraverseBreadthFirstPreservesChildrenOrder() { using var root = Enumerable.Range(1, 10).AsTestingSequence(); @@ -47,7 +47,7 @@ public static Tree New(T value, params Tree[] children) => new(value, children); } - [Fact] + [Test] public void TraverseBreadthFirstTraversesBreadthFirst() { var tree = Tree.New(1, @@ -60,7 +60,7 @@ public void TraverseBreadthFirstTraversesBreadthFirst() res.AssertSequenceEqual(1, 2, 5, 3, 6); } - [Fact] + [Test] public void TraverseDepthFirstTraversesDepthFirst() { var tree = Tree.New(1, diff --git a/Tests/SuperLinq.Tests/TrySingleTest.cs b/Tests/SuperLinq.Tests/TrySingleTest.cs new file mode 100644 index 000000000..14dc973f1 --- /dev/null +++ b/Tests/SuperLinq.Tests/TrySingleTest.cs @@ -0,0 +1,125 @@ +using System.Collections; + +namespace SuperLinq.Tests; + +public sealed class TrySingleTest +{ + public static IEnumerable> GetAllSequences(int numElements) => + Enumerable.Range(1, numElements).Cast().GetAllSequences(); + + [Test] + [MethodDataSource(nameof(GetAllSequences), Arguments = [0])] + public void TrySingleWithEmptySource(IDisposableEnumerable seq) + { + using (seq) + { + var value = seq.TrySingle(); + + Assert.Null(value); + } + } + + [Test] + [MethodDataSource(nameof(GetAllSequences), Arguments = [1])] + public void TrySingleWithSingleton(IDisposableEnumerable seq) + { + using (seq) + { + var value = seq.TrySingle(); + + Assert.Equal(1, value); + } + } + + [Test] + public void TrySingleWithSingletonCollection() + { + var source = new BreakingSingleElementCollection(10); + var value = source.TrySingle(); + + Assert.Equal(10, value); + } + + [Test] + [MethodDataSource(nameof(GetAllSequences), Arguments = [2])] + public void TrySingleWithMoreThanOne(IDisposableEnumerable seq) + { + using (seq) + { + var value = seq.TrySingle(); + + Assert.Null(value); + } + } + + [Test] + [MethodDataSource(nameof(GetAllSequences), Arguments = [0])] + public void TrySingleCardinalityWithEmptySource(IDisposableEnumerable seq) + { + using (seq) + { + var (cardinality, value) = seq.TrySingle("zero", "one", "many"); + + Assert.Equal("zero", cardinality); + Assert.Null(value); + } + } + + [Test] + [MethodDataSource(nameof(GetAllSequences), Arguments = [1])] + public void TrySingleCardinalityWithSingleton(IDisposableEnumerable seq) + { + using (seq) + { + var (cardinality, value) = seq.TrySingle("zero", "one", "many"); + + Assert.Equal("one", cardinality); + Assert.Equal(1, value); + } + } + + [Test] + public void TrySingleCardinalityWithSingletonCollection() + { + var source = new BreakingSingleElementCollection(10); + var (cardinality, value) = source.TrySingle("zero", "one", "many"); + + Assert.Equal("one", cardinality); + Assert.Equal(10, value); + } + + [Test] + [MethodDataSource(nameof(GetAllSequences), Arguments = [2])] + public void TrySingleCardinalityWithMoreThanOne(IDisposableEnumerable seq) + { + using (seq) + { + var (cardinality, value) = seq.TrySingle("zero", "one", "many"); + + Assert.Equal("many", cardinality); + Assert.Null(value); + } + } +} + +file sealed class BreakingSingleElementCollection( + T element +) : ICollection +{ + public int Count { get; } = 1; + + public IEnumerator GetEnumerator() + { + yield return element; + throw new InvalidOperationException($"{nameof(SuperEnumerable.TrySingle)} should not have attempted to consume a second element."); + } + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + public void Add(T item) => throw new NotSupportedException(); + public void Clear() => throw new NotSupportedException(); + public bool Contains(T item) => throw new NotSupportedException(); + public void CopyTo(T[] array, int arrayIndex) => throw new NotSupportedException(); + public bool Remove(T item) => throw new NotSupportedException(); + public bool IsReadOnly => true; +} diff --git a/Tests/SuperLinq.Test/UpdatablePriorityQueueTest.cs b/Tests/SuperLinq.Tests/UpdatablePriorityQueueTest.cs similarity index 86% rename from Tests/SuperLinq.Test/UpdatablePriorityQueueTest.cs rename to Tests/SuperLinq.Tests/UpdatablePriorityQueueTest.cs index 73d33e12c..40b75c00a 100644 --- a/Tests/SuperLinq.Test/UpdatablePriorityQueueTest.cs +++ b/Tests/SuperLinq.Tests/UpdatablePriorityQueueTest.cs @@ -6,29 +6,28 @@ using System.Reflection; using SuperLinq.Collections; -namespace Test; +namespace SuperLinq.Tests; public sealed class UpdatableUpdatablePriorityQueueTest { public abstract class TestBase { - public static IEnumerable ValidCollectionSizes() - { - yield return new object[] { 0 }; - yield return new object[] { 1 }; - yield return new object[] { 75 }; - } + public static IEnumerable ValidCollectionSizes() => + [ + 0, + 1, + 75, + ]; - public static IEnumerable ValidPositiveCollectionSizes() - { - yield return new object[] { 1 }; - yield return new object[] { 75 }; - } + public static IEnumerable ValidPositiveCollectionSizes() => + [ + 1, + 75, + ]; } public abstract class UpdatablePriorityQueue_Generic_Tests : TestBase { - #region Helpers protected abstract (TElement, TPriority) CreateT(int seed); @@ -59,7 +58,7 @@ protected UpdatablePriorityQueue CreateUpdatablePriorityQue #region Constructors - [Fact] + [Test] public void UpdatablePriorityQueue_DefaultConstructor_ComparerEqualsDefaultComparer() { var queue = new UpdatablePriorityQueue(); @@ -69,15 +68,15 @@ public void UpdatablePriorityQueue_DefaultConstructor_ComparerEqualsDefaultCompa Assert.Equal(queue.Comparer, Comparer.Default); } - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_EmptyCollection_UnorderedItemsIsEmpty(int initialCapacity) { var queue = new UpdatablePriorityQueue(initialCapacity); Assert.Empty(queue.UnorderedItems); } - [Fact] + [Test] public void UpdatablePriorityQueue_ComparerConstructor_ComparerShouldEqualParameter() { var comparer = GetPriorityComparer(); @@ -85,7 +84,7 @@ public void UpdatablePriorityQueue_ComparerConstructor_ComparerShouldEqualParame Assert.Equal(comparer, queue.Comparer); } - [Fact] + [Test] public void UpdatablePriorityQueue_PriorityComparerConstructorNull_ComparerShouldEqualDefaultComparer() { var queue = new UpdatablePriorityQueue(priorityComparer: null); @@ -93,8 +92,8 @@ public void UpdatablePriorityQueue_PriorityComparerConstructorNull_ComparerShoul Assert.Same(Comparer.Default, queue.Comparer); } - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_CapacityConstructor_ComparerShouldEqualDefaultComparer(int initialCapacity) { var queue = new UpdatablePriorityQueue(initialCapacity); @@ -102,8 +101,8 @@ public void UpdatablePriorityQueue_CapacityConstructor_ComparerShouldEqualDefaul Assert.Same(Comparer.Default, queue.Comparer); } - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_EnumerableConstructor_ShouldContainAllElements(int count) { var itemsToEnqueue = CreateItems(count).ToArray(); @@ -116,8 +115,8 @@ public void UpdatablePriorityQueue_EnumerableConstructor_ShouldContainAllElement #region Enqueue, Dequeue, Peek, EnqueueDequeue - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_Enqueue_IEnumerable(int count) { var itemsToEnqueue = CreateItems(count).ToArray(); @@ -129,8 +128,8 @@ public void UpdatablePriorityQueue_Enqueue_IEnumerable(int count) queue.UnorderedItems.AssertCollectionEqual(itemsToEnqueue); } - [Theory] - [MemberData(nameof(ValidPositiveCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidPositiveCollectionSizes))] public void UpdatablePriorityQueue_Peek_ShouldReturnMinimalElement(int count) { var itemsToEnqueue = CreateItems(count).ToArray(); @@ -154,10 +153,10 @@ public void UpdatablePriorityQueue_Peek_ShouldReturnMinimalElement(int count) } } - [Theory] - [InlineData(0, 5)] - [InlineData(1, 1)] - [InlineData(3, 100)] + [Test] + [Arguments(0, 5)] + [Arguments(1, 1)] + [Arguments(3, 100)] public void UpdatablePriorityQueue_PeekAndDequeue(int initialCapacity, int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity, count, out var generatedItems); @@ -185,8 +184,8 @@ public void UpdatablePriorityQueue_PeekAndDequeue(int initialCapacity, int count Assert.False(queue.TryDequeue(out _, out _)); } - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_EnqueueRange_IEnumerable(int count) { var itemsToEnqueue = CreateItems(count).ToArray(); @@ -197,8 +196,8 @@ public void UpdatablePriorityQueue_EnqueueRange_IEnumerable(int count) queue.UnorderedItems.AssertCollectionEqual(itemsToEnqueue, comparer: GetNodeComparer()); } - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_EnqueueDequeue(int count) { (TElement Element, TPriority Priority)[] itemsToEnqueue = CreateItems(2 * count).ToArray(); @@ -216,8 +215,8 @@ public void UpdatablePriorityQueue_EnqueueDequeue(int count) #region Clear - [Theory] - [MemberData(nameof(ValidCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidCollectionSizes))] public void UpdatablePriorityQueue_Clear(int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity: 0, count, out _); @@ -233,8 +232,8 @@ public void UpdatablePriorityQueue_Clear(int count) #region Enumeration - [Theory] - [MemberData(nameof(ValidPositiveCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidPositiveCollectionSizes))] public void UpdatablePriorityQueue_Enumeration_OrderingIsConsistent(int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity: 0, count, out _); @@ -249,6 +248,7 @@ public void UpdatablePriorityQueue_Enumeration_OrderingIsConsistent(int count) #endregion } + [InheritsTests] public class UpdatablePriorityQueue_Generic_Tests_string_string : UpdatablePriorityQueue_Generic_Tests { protected override (string, string) CreateT(int seed) @@ -266,6 +266,7 @@ static string CreateString(Random random) } } + [InheritsTests] public class UpdatablePriorityQueue_Generic_Tests_int_int : UpdatablePriorityQueue_Generic_Tests { protected override (int, int) CreateT(int seed) @@ -275,16 +276,19 @@ protected override (int, int) CreateT(int seed) } } + [InheritsTests] public sealed class PriorityQueue_Generic_Tests_string_string_CustomPriorityComparer : UpdatablePriorityQueue_Generic_Tests_string_string { protected override IComparer GetPriorityComparer() => StringComparer.InvariantCultureIgnoreCase; } + [InheritsTests] public sealed class PriorityQueue_Generic_Tests_string_string_CustomElementComparer : UpdatablePriorityQueue_Generic_Tests_string_string { protected override IEqualityComparer? GetElementComparer() => StringComparer.InvariantCultureIgnoreCase; } + [InheritsTests] public sealed class PriorityQueue_Generic_Tests_int_int_CustomComparer : UpdatablePriorityQueue_Generic_Tests_int_int { protected override IComparer GetPriorityComparer() => Comparer.Create((x, y) => -x.CompareTo(y)); @@ -314,7 +318,7 @@ private static UpdatablePriorityQueue CreateUpdatablePriorityQueue(int return pq; } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueDequeue_Empty() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -323,7 +327,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueDequeue_Empty() Assert.Equal(0, queue.Count); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueDequeue_SmallerThanMin() { var queue = CreateSmallUpdatablePriorityQueue(out var enqueuedItems); @@ -334,7 +338,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueDequeue_SmallerThanMin() Assert.True(enqueuedItems.SetEquals(queue.UnorderedItems)); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueDequeue_LargerThanMin() { var queue = CreateSmallUpdatablePriorityQueue(out var _); @@ -347,7 +351,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueDequeue_LargerThanMin() Assert.Equal("four", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueDequeue_EqualToMin() { var queue = CreateSmallUpdatablePriorityQueue(out var enqueuedItems); @@ -358,7 +362,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueDequeue_EqualToMin() Assert.True(enqueuedItems.SetEquals(queue.UnorderedItems)); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_Constructor_IEnumerable_Null() { var itemsToEnqueue = new (string?, int)[] { (null, 0), ("one", 1) }; @@ -367,7 +371,7 @@ public void UpdatablePriorityQueue_Generic_Constructor_IEnumerable_Null() Assert.Equal("one", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_Enqueue_Null() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -381,7 +385,7 @@ public void UpdatablePriorityQueue_Generic_Enqueue_Null() Assert.Equal("two", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueRange_Null() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -394,7 +398,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueRange_Null() Assert.Equal("not null", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_Enqueue_ChangesPriority() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -421,7 +425,7 @@ public void UpdatablePriorityQueue_Generic_Enqueue_ChangesPriority() Assert.Equal("alpha", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueRange_ChangesPriority() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -451,7 +455,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueRange_ChangesPriority() Assert.Equal("alpha", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueMinimum_UsesLowestPriority() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -475,7 +479,7 @@ public void UpdatablePriorityQueue_Generic_EnqueueMinimum_UsesLowestPriority() Assert.Equal("delta", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Generic_EnqueueRangeMinimum_UsesLowestPriority() { var queue = new UpdatablePriorityQueue(StringComparer.Ordinal); @@ -502,28 +506,28 @@ public void UpdatablePriorityQueue_Generic_EnqueueRangeMinimum_UsesLowestPriorit Assert.Equal("delta", queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_Constructor_int_Negative_ThrowsArgumentOutOfRangeException() { _ = Assert.Throws("initialCapacity", () => new UpdatablePriorityQueue(-1)); _ = Assert.Throws("initialCapacity", () => new UpdatablePriorityQueue(int.MinValue)); } - [Fact] + [Test] public void UpdatablePriorityQueue_Constructor_Enumerable_null_ThrowsArgumentNullException() { _ = Assert.Throws("items", () => new UpdatablePriorityQueue(items: null!)); _ = Assert.Throws("items", () => new UpdatablePriorityQueue(items: null!, priorityComparer: Comparer.Default, elementComparer: EqualityComparer.Default)); } - [Fact] + [Test] public void UpdatablePriorityQueue_EnqueueRange_null_ThrowsArgumentNullException() { var queue = new UpdatablePriorityQueue(); _ = Assert.Throws("items", () => queue.EnqueueRange(null!)); } - [Fact] + [Test] public void UpdatablePriorityQueue_EmptyCollection_Dequeue_ShouldThrowException() { var queue = new UpdatablePriorityQueue(); @@ -533,7 +537,7 @@ public void UpdatablePriorityQueue_EmptyCollection_Dequeue_ShouldThrowException( _ = Assert.Throws(() => queue.Dequeue()); } - [Fact] + [Test] public void UpdatablePriorityQueue_EmptyCollection_Peek_ShouldReturnFalse() { var queue = new UpdatablePriorityQueue(); @@ -544,7 +548,7 @@ public void UpdatablePriorityQueue_EmptyCollection_Peek_ShouldReturnFalse() #region EnsureCapacity, TrimExcess - [Fact] + [Test] public void UpdatablePriorityQueue_EnsureCapacity_Negative_ShouldThrowException() { var queue = new UpdatablePriorityQueue(); @@ -552,11 +556,11 @@ public void UpdatablePriorityQueue_EnsureCapacity_Negative_ShouldThrowException( _ = Assert.Throws("capacity", () => queue.EnsureCapacity(int.MinValue)); } - [Theory] - [InlineData(0, 0)] - [InlineData(0, 5)] - [InlineData(1, 1)] - [InlineData(3, 100)] + [Test] + [Arguments(0, 0)] + [Arguments(0, 5)] + [Arguments(1, 1)] + [Arguments(3, 100)] public void UpdatablePriorityQueue_TrimExcess_ShouldNotChangeCount(int initialCapacity, int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity, count); @@ -566,8 +570,8 @@ public void UpdatablePriorityQueue_TrimExcess_ShouldNotChangeCount(int initialCa Assert.Equal(count, queue.Count); } - [Theory] - [MemberData(nameof(ValidPositiveCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidPositiveCollectionSizes))] public void UpdatablePriorityQueue_TrimExcess_Repeatedly_ShouldNotChangeCount(int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity: count, count); @@ -579,8 +583,8 @@ public void UpdatablePriorityQueue_TrimExcess_Repeatedly_ShouldNotChangeCount(in Assert.Equal(count, queue.Count); } - [Theory] - [MemberData(nameof(ValidPositiveCollectionSizes))] + [Test] + [MethodDataSource(nameof(ValidPositiveCollectionSizes))] public void UpdatablePriorityQueue_Generic_EnsureCapacityAndTrimExcess(int count) { IReadOnlyCollection<(int, int)> itemsToEnqueue = Enumerable.Range(1, count).Select(i => (i, i)).ToArray(); @@ -632,8 +636,8 @@ private static int GetUnderlyingBufferCapacity(UpdatablePri #region Enumeration - [Theory] - [MemberData(nameof(GetNonModifyingOperations))] + [Test] + [MethodDataSource(nameof(GetNonModifyingOperations))] public void UpdatablePriorityQueue_Enumeration_ValidOnNonModifyingOperation(Action> nonModifyingOperation, int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity: count, count: count); @@ -642,8 +646,8 @@ public void UpdatablePriorityQueue_Enumeration_ValidOnNonModifyingOperation(Acti _ = enumerator.MoveNext(); } - [Theory] - [MemberData(nameof(GetModifyingOperations))] + [Test] + [MethodDataSource(nameof(GetModifyingOperations))] public void UpdatablePriorityQueue_Enumeration_InvalidationOnModifyingOperation(Action> modifyingOperation, int count) { var queue = CreateUpdatablePriorityQueue(initialCapacity: count, count: count); @@ -652,37 +656,33 @@ public void UpdatablePriorityQueue_Enumeration_InvalidationOnModifyingOperation( _ = Assert.Throws(() => enumerator.MoveNext()); } - public static IEnumerable GetModifyingOperations() - { - yield return WrapArg(queue => queue.Enqueue(42, 0), 0); - yield return WrapArg(queue => queue.Dequeue(), 5); - yield return WrapArg(queue => queue.TryDequeue(out _, out _), 5); - yield return WrapArg(queue => queue.EnqueueDequeue(5, priority: int.MaxValue), 5); - yield return WrapArg(queue => queue.EnqueueDequeue(5, priority: int.MaxValue), 5); - yield return WrapArg(queue => queue.EnqueueRange([(1, 2)]), 0); - yield return WrapArg(queue => queue.EnqueueRange([(1, 2)]), 10); - yield return WrapArg(queue => queue.EnqueueRange([1, 2], 42), 0); - yield return WrapArg(queue => queue.EnqueueRange([1, 2], 42), 10); - yield return WrapArg(queue => queue.EnsureCapacity(2 * queue.Count), 4); - yield return WrapArg(queue => queue.Clear(), 5); - yield return WrapArg(queue => queue.Clear(), 0); - - static object[] WrapArg(Action> arg, int queueCount) => [arg, queueCount]; - } - - public static IEnumerable GetNonModifyingOperations() - { - yield return WrapArg(queue => queue.Peek(), 1); - yield return WrapArg(queue => queue.TryPeek(out _, out _), 1); - yield return WrapArg(queue => queue.TryDequeue(out _, out _), 0); - yield return WrapArg(queue => queue.EnqueueDequeue(5, priority: int.MinValue), 1); - yield return WrapArg(queue => queue.EnqueueDequeue(5, priority: int.MaxValue), 0); - yield return WrapArg(queue => queue.EnqueueRange([]), 5); - yield return WrapArg(queue => queue.EnqueueRange([], 42), 5); - yield return WrapArg(queue => queue.EnsureCapacity(5), 5); + public static IEnumerable<(Action> arg, int queueCount)> GetModifyingOperations() => + [ + (queue => queue.Enqueue(42, 0), 0), + (queue => queue.Dequeue(), 5), + (queue => queue.TryDequeue(out _, out _), 5), + (queue => queue.EnqueueDequeue(5, priority: int.MaxValue), 5), + (queue => queue.EnqueueDequeue(5, priority: int.MaxValue), 5), + (queue => queue.EnqueueRange([(1, 2)]), 0), + (queue => queue.EnqueueRange([(1, 2)]), 10), + (queue => queue.EnqueueRange([1, 2], 42), 0), + (queue => queue.EnqueueRange([1, 2], 42), 10), + (queue => queue.EnsureCapacity(2 * queue.Count), 4), + (queue => queue.Clear(), 5), + (queue => queue.Clear(), 0), + ]; - static object[] WrapArg(Action> arg, int queueCount) => [arg, queueCount]; - } + public static IEnumerable<(Action> arg, int queueCount)> GetNonModifyingOperations() => + [ + (queue => queue.Peek(), 1), + (queue => queue.TryPeek(out _, out _), 1), + (queue => queue.TryDequeue(out _, out _), 0), + (queue => queue.EnqueueDequeue(5, priority: int.MinValue), 1), + (queue => queue.EnqueueDequeue(5, priority: int.MaxValue), 0), + (queue => queue.EnqueueRange([]), 5), + (queue => queue.EnqueueRange([], 42), 5), + (queue => queue.EnsureCapacity(5), 5), + ]; #endregion } diff --git a/Tests/SuperLinq.Test/UsingTest.cs b/Tests/SuperLinq.Tests/UsingTest.cs similarity index 96% rename from Tests/SuperLinq.Test/UsingTest.cs rename to Tests/SuperLinq.Tests/UsingTest.cs index 4791d63b2..c11b16c3d 100644 --- a/Tests/SuperLinq.Test/UsingTest.cs +++ b/Tests/SuperLinq.Tests/UsingTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class UsingTest { - [Fact] + [Test] public void UsingIsLazy() { _ = SuperEnumerable.Using( @@ -10,7 +10,7 @@ public void UsingIsLazy() BreakingFunc.Of>()); } - [Fact] + [Test] public void UsingDisposesCorrectly() { var starts = 0; @@ -36,7 +36,7 @@ IEnumerable Test(TestDisposable disposable) Assert.Equal(1, starts); } - [Fact] + [Test] public void UsingDisposesOnIterationError() { var starts = 0; @@ -62,7 +62,7 @@ IEnumerable Test(TestDisposable disposable) Assert.Equal(1, starts); } - [Fact] + [Test] public void UsingDisposesOnFunctionError() { TestDisposable? dis = null; diff --git a/Tests/SuperLinq.Test/ValueTupleComparerTest.cs b/Tests/SuperLinq.Tests/ValueTupleComparerTest.cs similarity index 96% rename from Tests/SuperLinq.Test/ValueTupleComparerTest.cs rename to Tests/SuperLinq.Tests/ValueTupleComparerTest.cs index 35e2f5cb8..4a293d31a 100644 --- a/Tests/SuperLinq.Test/ValueTupleComparerTest.cs +++ b/Tests/SuperLinq.Tests/ValueTupleComparerTest.cs @@ -1,6 +1,6 @@ using System.Diagnostics.CodeAnalysis; -namespace Test; +namespace SuperLinq.Tests; public sealed class ValueTupleComparerTest { @@ -14,7 +14,7 @@ public int Compare([AllowNull] string x, [AllowNull] string y) } } - [Fact] + [Test] public void ValueTupleComparerShouldCreateWithDefaultComparers() { var comparer = ValueTupleComparer.Create(comparer1: null, comparer2: null); @@ -24,7 +24,7 @@ public void ValueTupleComparerShouldCreateWithDefaultComparers() Assert.Equal(-1, result); } - [Fact] + [Test] public void ValueTupleComparerShouldCheckSecondItemIfFirstIsZero() { var comparer = ValueTupleComparer.Create(comparer1: null, comparer2: null); @@ -34,7 +34,7 @@ public void ValueTupleComparerShouldCheckSecondItemIfFirstIsZero() Assert.Equal(1, result); } - [Fact] + [Test] public void ValueTupleComparerShouldAcceptCustomComparers() { TestComparer innerLeftComparer = new(); diff --git a/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs b/Tests/SuperLinq.Tests/ValueTupleEqualityComparerTest.cs similarity index 97% rename from Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs rename to Tests/SuperLinq.Tests/ValueTupleEqualityComparerTest.cs index 23c6e862c..48962476f 100644 --- a/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs +++ b/Tests/SuperLinq.Tests/ValueTupleEqualityComparerTest.cs @@ -2,7 +2,7 @@ using System.Diagnostics.CodeAnalysis; #endif -namespace Test; +namespace SuperLinq.Tests; public sealed class ValueTupleEqualityComparerTest { @@ -17,7 +17,7 @@ private sealed class TestComparer(Func comparer) : IEqualityCom #endif } - [Fact] + [Test] public void ValueTupleEqualityComparerWithOneTypeArgShouldCreateWhenNoComparerProvided() { var comparer = ValueTupleEqualityComparer.Create(comparer1: null); @@ -27,7 +27,7 @@ public void ValueTupleEqualityComparerWithOneTypeArgShouldCreateWhenNoComparerPr Assert.True(result); } - [Fact] + [Test] public void ValueTupleEqualityComparerWithOneTypeArgShouldGetHashCode() { var comparer = ValueTupleEqualityComparer.Create(comparer1: null); @@ -40,7 +40,7 @@ public void ValueTupleEqualityComparerWithOneTypeArgShouldGetHashCode() Assert.Equal(2.GetHashCode(), secondHashCode); } - [Fact] + [Test] public void ValueTupleEqualityComparerWithOneTypeArgShouldCreateWhenComparerProvided() { var innerComparer = new TestComparer((x, y) => x?.Value == y?.Value); @@ -51,7 +51,7 @@ public void ValueTupleEqualityComparerWithOneTypeArgShouldCreateWhenComparerProv Assert.True(result); } - [Fact] + [Test] public void ValueTupleEqualityComparerWithTwoTypeArgsShouldCreateWhenNoComparerProvided() { var comparer = ValueTupleEqualityComparer.Create(comparer1: null, comparer2: null); @@ -61,7 +61,7 @@ public void ValueTupleEqualityComparerWithTwoTypeArgsShouldCreateWhenNoComparerP Assert.True(result); } - [Fact] + [Test] public void ValueTupleEqualityComparerWithTwoTypeArgsShouldCreateWhenComparerProvided() { var innerComparerLeft = new TestComparer((x, y) => x?.Value == y?.Value); @@ -73,7 +73,7 @@ public void ValueTupleEqualityComparerWithTwoTypeArgsShouldCreateWhenComparerPro Assert.True(result); } - [Fact] + [Test] public void ValueTupleEqualityComparerWithTwoTypeArgsShouldGetHashCode() { var comparer = ValueTupleEqualityComparer.Create(comparer1: null, comparer2: null); diff --git a/Tests/SuperLinq.Test/WatchableEnumerator.cs b/Tests/SuperLinq.Tests/WatchableEnumerator.cs similarity index 87% rename from Tests/SuperLinq.Test/WatchableEnumerator.cs rename to Tests/SuperLinq.Tests/WatchableEnumerator.cs index 2fcdf2d8a..45b716d4a 100644 --- a/Tests/SuperLinq.Test/WatchableEnumerator.cs +++ b/Tests/SuperLinq.Tests/WatchableEnumerator.cs @@ -1,13 +1,13 @@ using System.Collections; -namespace Test; +namespace SuperLinq.Tests; -internal partial class TestExtensions +public partial class TestExtensions { public static WatchableEnumerator AsWatchable(this IEnumerator source) => new(source); } -internal sealed class WatchableEnumerator : IEnumerator +public sealed class WatchableEnumerator : IEnumerator { private readonly IEnumerator _source; diff --git a/Tests/SuperLinq.Test/WhereLagTest.cs b/Tests/SuperLinq.Tests/WhereLagTest.cs similarity index 95% rename from Tests/SuperLinq.Test/WhereLagTest.cs rename to Tests/SuperLinq.Tests/WhereLagTest.cs index 5bc8647f7..a4b43df24 100644 --- a/Tests/SuperLinq.Test/WhereLagTest.cs +++ b/Tests/SuperLinq.Tests/WhereLagTest.cs @@ -1,22 +1,22 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class WhereLagTest { - [Fact] + [Test] public void WhereLagIsLazy() { _ = new BreakingSequence().WhereLag(5, BreakingFunc.Of()); _ = new BreakingSequence().WhereLag(5, -1, BreakingFunc.Of()); } - [Fact] + [Test] public void WhereLagZeroOffset() { _ = Assert.Throws(() => new BreakingSequence().WhereLag(0, BreakingFunc.Of())); } - [Fact] + [Test] public void WhereLagExplicitDefaultValue() { using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -25,7 +25,7 @@ public void WhereLagExplicitDefaultValue() 2, 7, 17, 27, 37, 47, 57, 67, 77, 87, 97); } - [Fact] + [Test] public void WhereLagImplicitDefaultValue() { using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -34,7 +34,7 @@ public void WhereLagImplicitDefaultValue() 1, 7, 17, 27, 37, 47, 57, 67, 77, 87, 97); } - [Fact] + [Test] public void WhereLagOffsetGreaterThanSequenceLength() { using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -42,7 +42,7 @@ public void WhereLagOffsetGreaterThanSequenceLength() result.AssertSequenceEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public void WhereLagWithNullableReferences() { using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); @@ -50,7 +50,7 @@ public void WhereLagWithNullableReferences() result.AssertSequenceEqual("foo", "baz"); } - [Fact] + [Test] public void WhereLagWithNonNullableReferences() { using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/WhereLeadTest.cs b/Tests/SuperLinq.Tests/WhereLeadTest.cs similarity index 95% rename from Tests/SuperLinq.Test/WhereLeadTest.cs rename to Tests/SuperLinq.Tests/WhereLeadTest.cs index fd1854446..6ef949c5f 100644 --- a/Tests/SuperLinq.Test/WhereLeadTest.cs +++ b/Tests/SuperLinq.Tests/WhereLeadTest.cs @@ -1,22 +1,22 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class WhereLeadTest { - [Fact] + [Test] public void WhereLeadIsLazy() { _ = new BreakingSequence().WhereLead(5, BreakingFunc.Of()); _ = new BreakingSequence().WhereLead(5, -1, BreakingFunc.Of()); } - [Fact] + [Test] public void WhereLeadZeroOffset() { _ = Assert.Throws(() => new BreakingSequence().WhereLead(0, BreakingFunc.Of())); } - [Fact] + [Test] public void WhereLeadExplicitDefaultValue() { using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -25,7 +25,7 @@ public void WhereLeadExplicitDefaultValue() 7, 17, 27, 37, 47, 48, 57, 67, 77, 87, 97, 100); } - [Fact] + [Test] public void WhereLeadImplicitDefaultValue() { using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -34,7 +34,7 @@ public void WhereLeadImplicitDefaultValue() 9, 19, 29, 39, 48, 49, 59, 69, 79, 89, 99); } - [Fact] + [Test] public void WhereLeadOffsetGreaterThanSequenceLength() { using var seq = Enumerable.Range(1, 100).AsTestingSequence(); @@ -42,7 +42,7 @@ public void WhereLeadOffsetGreaterThanSequenceLength() result.AssertSequenceEqual(Enumerable.Range(1, 100)); } - [Fact] + [Test] public void WhereLeadWithNullableReferences() { using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); @@ -50,7 +50,7 @@ public void WhereLeadWithNullableReferences() result.AssertSequenceEqual("foo", "baz"); } - [Fact] + [Test] public void WhereLeadWithNonNullableReferences() { using var seq = Seq("foo", "bar", "baz", "qux").AsTestingSequence(); diff --git a/Tests/SuperLinq.Test/WhereTest.cs b/Tests/SuperLinq.Tests/WhereTest.cs similarity index 89% rename from Tests/SuperLinq.Test/WhereTest.cs rename to Tests/SuperLinq.Tests/WhereTest.cs index 2de65535c..af690276f 100644 --- a/Tests/SuperLinq.Test/WhereTest.cs +++ b/Tests/SuperLinq.Tests/WhereTest.cs @@ -1,23 +1,23 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class WhereTest { - [Fact] + [Test] public void WhereIsLazy() { _ = new BreakingSequence().Where(new BreakingSequence()); } - [Theory] - [InlineData(2, 3)] - [InlineData(3, 2)] + [Test] + [Arguments(2, 3)] + [Arguments(3, 2)] public void WhereRequiresEqualLengths(int sLength, int fLength) { _ = Assert.Throws(() => Enumerable.Repeat(1, sLength).Where(Enumerable.Repeat(false, fLength)).Consume()); } - [Fact] + [Test] public void WhereFiltersIntSequence() { var seq = Enumerable.Range(1, 10); @@ -29,7 +29,7 @@ public void WhereFiltersIntSequence() seq.Where(x => x % 2 == 0)); } - [Fact] + [Test] public void WhereFiltersStringSequence() { var words = Seq("foo", "hello", "world", "Bar", "QuX", "ay", "az"); diff --git a/Tests/SuperLinq.Test/WhileTest.cs b/Tests/SuperLinq.Tests/WhileTest.cs similarity index 92% rename from Tests/SuperLinq.Test/WhileTest.cs rename to Tests/SuperLinq.Tests/WhileTest.cs index 296940a03..ac211d9e1 100644 --- a/Tests/SuperLinq.Test/WhileTest.cs +++ b/Tests/SuperLinq.Tests/WhileTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class WhileTest { - [Fact] + [Test] public void WhileIsLazy() { _ = SuperEnumerable.While( @@ -10,7 +10,7 @@ public void WhileIsLazy() new BreakingSequence()); } - [Fact] + [Test] public void WhileBehavior() { var starts = 0; diff --git a/Tests/SuperLinq.Test/WindowLeftTest.cs b/Tests/SuperLinq.Tests/WindowLeftTest.cs similarity index 71% rename from Tests/SuperLinq.Test/WindowLeftTest.cs rename to Tests/SuperLinq.Tests/WindowLeftTest.cs index 518542bfd..3a3a6d276 100644 --- a/Tests/SuperLinq.Test/WindowLeftTest.cs +++ b/Tests/SuperLinq.Tests/WindowLeftTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class WindowLeftTest { - [Fact] + [Test] public void WindowLeftIsLazy() { _ = new BreakingSequence().WindowLeft(1); @@ -11,7 +11,7 @@ public void WindowLeftIsLazy() _ = new BreakingSequence().WindowLeft(new int[3], 1, BreakingReadOnlySpanFunc.Of()); } - [Fact] + [Test] public void WindowLeftNegativeWindowSizeException() { _ = Assert.Throws(() => @@ -30,13 +30,12 @@ public void WindowLeftNegativeWindowSizeException() .WindowLeft(new int[5], 5, BreakingReadOnlySpanFunc.Of()); } - public static IEnumerable GetThreeElementSequences() => + public static IEnumerable> GetThreeElementSequences() => Enumerable.Range(0, 3) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow(IDisposableEnumerable seq) { using (seq) @@ -53,8 +52,8 @@ public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow(IDisposableEnume } } - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow(IDisposableEnumerable seq) { using (seq) @@ -71,8 +70,8 @@ public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow(IDisposableEnumer } } - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedDoesNotAffectPreviousWindow(IDisposableEnumerable seq) { using (seq) @@ -97,14 +96,14 @@ public enum WindowMethod BufferSizeArray, } - private static IEnumerable GetWindowTestSequences(IEnumerable source) + private static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetWindowTestSequences(IEnumerable source) { foreach (var seq in source.GetListSequences()) - yield return new object[] { seq, WindowMethod.Traditional }; + yield return (seq, WindowMethod.Traditional); - yield return new object[] { source.AsTestingSequence(), WindowMethod.BufferSize }; - yield return new object[] { source.AsTestingSequence(), WindowMethod.BufferArray }; - yield return new object[] { source.AsTestingSequence(), WindowMethod.BufferSizeArray }; + yield return (source.AsTestingSequence(), WindowMethod.BufferSize); + yield return (source.AsTestingSequence(), WindowMethod.BufferArray); + yield return (source.AsTestingSequence(), WindowMethod.BufferSizeArray); } private static IEnumerable> GetWindows( @@ -120,62 +119,62 @@ private static IEnumerable> GetWindows( _ => throw new NotSupportedException(), }; - public static IEnumerable GetEmptySequences() => + public static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetEmptySequences() => GetWindowTestSequences([]); - [Theory] - [MemberData(nameof(GetEmptySequences))] - public void WindowLeftEmptySequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetEmptySequences))] + public void WindowLeftEmptySequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 5); + var result = GetWindows(seq, windowMethod, 5); result.AssertSequenceEqual(); } } - public static IEnumerable GetHundredElementSequences() => + public static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetHundredElementSequences() => GetWindowTestSequences(Enumerable.Range(0, 100)); - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void WindowLeftOfSingleElement(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void WindowLeftOfSingleElement(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 1); + var result = GetWindows(seq, windowMethod, 1); foreach (var (actual, expected) in result.Zip(Enumerable.Range(0, 100))) Assert.Equal(SuperEnumerable.Return(expected), actual); } } - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void WindowLeftWithWindowSizeSmallerThanSequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void WindowLeftWithWindowSizeSmallerThanSequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 10); + var result = GetWindows(seq, windowMethod, 10); result.AssertSequenceEqual( Enumerable.Range(0, 100) .Select(i => Enumerable.Range(i, Math.Min(10, 100 - i)))); } } - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void WindowLeftWithWindowSizeLargerThanSequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void WindowLeftWithWindowSizeLargerThanSequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 110); + var result = GetWindows(seq, windowMethod, 110); result.AssertSequenceEqual( Enumerable.Range(0, 100) .Select(i => Enumerable.Range(i, 100 - i))); } } - [Fact] + [Test] public void WindowLeftListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/WindowRightTest.cs b/Tests/SuperLinq.Tests/WindowRightTest.cs similarity index 71% rename from Tests/SuperLinq.Test/WindowRightTest.cs rename to Tests/SuperLinq.Tests/WindowRightTest.cs index 746f26b37..d5cae18fd 100644 --- a/Tests/SuperLinq.Test/WindowRightTest.cs +++ b/Tests/SuperLinq.Tests/WindowRightTest.cs @@ -1,8 +1,8 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class WindowRightTest { - [Fact] + [Test] public void WindowRightIsLazy() { _ = new BreakingSequence().WindowRight(1); @@ -11,7 +11,7 @@ public void WindowRightIsLazy() _ = new BreakingSequence().WindowRight(new int[3], 1, BreakingReadOnlySpanFunc.Of()); } - [Fact] + [Test] public void WindowRightNegativeWindowSizeException() { var sequence = Enumerable.Repeat(1, 10); @@ -32,13 +32,12 @@ public void WindowRightNegativeWindowSizeException() .WindowRight(new int[5], 5, BreakingReadOnlySpanFunc.Of()); } - public static IEnumerable GetThreeElementSequences() => + public static IEnumerable> GetThreeElementSequences() => Enumerable.Range(0, 3) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow(IDisposableEnumerable seq) { using (seq) @@ -55,8 +54,8 @@ public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow(IDisposableEnume } } - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow(IDisposableEnumerable seq) { using (seq) @@ -73,8 +72,8 @@ public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow(IDisposableEnumer } } - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedDoesNotAffectPreviousWindow(IDisposableEnumerable seq) { using (seq) @@ -99,14 +98,14 @@ public enum WindowMethod BufferSizeArray, } - private static IEnumerable GetWindowTestSequences(IEnumerable source) + private static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetWindowTestSequences(IEnumerable source) { foreach (var seq in source.GetListSequences()) - yield return new object[] { seq, WindowMethod.Traditional }; + yield return (seq, WindowMethod.Traditional); - yield return new object[] { source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSize }; - yield return new object[] { source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferArray }; - yield return new object[] { source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSizeArray }; + yield return (source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSize); + yield return (source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferArray); + yield return (source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSizeArray); } private static IEnumerable> GetWindows( @@ -122,42 +121,42 @@ private static IEnumerable> GetWindows( _ => throw new NotSupportedException(), }; - public static IEnumerable GetEmptySequences() => + public static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetEmptySequences() => GetWindowTestSequences([]); - [Theory] - [MemberData(nameof(GetEmptySequences))] - public void WindowRightEmptySequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetEmptySequences))] + public void WindowRightEmptySequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 5); + var result = GetWindows(seq, windowMethod, 5); result.AssertSequenceEqual(); } } - public static IEnumerable GetHundredElementSequences() => + public static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetHundredElementSequences() => GetWindowTestSequences(Enumerable.Range(0, 100)); - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void WindowRightOfSingleElement(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void WindowRightOfSingleElement(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 1); + var result = GetWindows(seq, windowMethod, 1); foreach (var (actual, expected) in result.Zip(Enumerable.Range(0, 100))) Assert.Equal(SuperEnumerable.Return(expected), actual); } } - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void WindowRightWithWindowSizeSmallerThanSequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void WindowRightWithWindowSizeSmallerThanSequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 10); + var result = GetWindows(seq, windowMethod, 10); result.AssertSequenceEqual( Enumerable.Range(0, 10) .Select(x => Enumerable.Range(0, x + 1)) @@ -166,20 +165,20 @@ public void WindowRightWithWindowSizeSmallerThanSequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void WindowRightWithWindowSizeLargerThanSequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 110); + var result = GetWindows(seq, windowMethod, 110); result.AssertSequenceEqual( Enumerable.Range(0, 100) .Select(i => Enumerable.Range(0, i + 1))); } } - [Fact] + [Test] public void WindowRightListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/WindowTest.cs b/Tests/SuperLinq.Tests/WindowTest.cs similarity index 71% rename from Tests/SuperLinq.Test/WindowTest.cs rename to Tests/SuperLinq.Tests/WindowTest.cs index d2a253f4e..82e7cf08a 100644 --- a/Tests/SuperLinq.Test/WindowTest.cs +++ b/Tests/SuperLinq.Tests/WindowTest.cs @@ -1,11 +1,11 @@ -namespace Test; +namespace SuperLinq.Tests; /// /// Verify the behavior of the Window operator /// public sealed class WindowTests { - [Fact] + [Test] public void TestWindowIsLazy() { _ = new BreakingSequence().Window(1); @@ -14,7 +14,7 @@ public void TestWindowIsLazy() _ = new BreakingSequence().Window(new int[3], 1, BreakingReadOnlySpanFunc.Of()); } - [Fact] + [Test] public void TestWindowNegativeWindowSizeException() { _ = Assert.Throws(() => @@ -33,13 +33,12 @@ public void TestWindowNegativeWindowSizeException() .Window(new int[5], 5, BreakingReadOnlySpanFunc.Of()); } - public static IEnumerable GetThreeElementSequences() => + public static IEnumerable> GetThreeElementSequences() => Enumerable.Range(0, 3) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow(IDisposableEnumerable seq) { using (seq) @@ -56,8 +55,8 @@ public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow(IDisposableEnume } } - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow(IDisposableEnumerable seq) { using (seq) @@ -74,8 +73,8 @@ public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow(IDisposableEnumer } } - [Theory] - [MemberData(nameof(GetThreeElementSequences))] + [Test] + [MethodDataSource(nameof(GetThreeElementSequences))] public void WindowModifiedDoesNotAffectPreviousWindow(IDisposableEnumerable seq) { using (seq) @@ -100,14 +99,14 @@ public enum WindowMethod BufferSizeArray, } - private static IEnumerable GetWindowTestSequences(IEnumerable source) + private static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetWindowTestSequences(IEnumerable source) { foreach (var seq in source.GetListSequences()) - yield return new object[] { seq, WindowMethod.Traditional }; + yield return (seq, WindowMethod.Traditional); - yield return new object[] { source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSize }; - yield return new object[] { source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferArray }; - yield return new object[] { source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSizeArray }; + yield return (source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSize); + yield return (source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferArray); + yield return (source.AsTestingSequence(maxEnumerations: 2), WindowMethod.BufferSizeArray); } private static IEnumerable> GetWindows( @@ -123,59 +122,59 @@ private static IEnumerable> GetWindows( _ => throw new NotSupportedException(), }; - public static IEnumerable GetEmptySequences() => + public static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetEmptySequences() => GetWindowTestSequences([]); - [Theory] - [MemberData(nameof(GetEmptySequences))] - public void TestWindowEmptySequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetEmptySequences))] + public void TestWindowEmptySequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 5); + var result = GetWindows(seq, windowMethod, 5); result.AssertSequenceEqual(); } } - public static IEnumerable GetHundredElementSequences() => + public static IEnumerable<(IDisposableEnumerable seq, WindowMethod windowMethod)> GetHundredElementSequences() => GetWindowTestSequences(Enumerable.Range(0, 100)); - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void TestWindowOfSingleElement(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void TestWindowOfSingleElement(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 1); + var result = GetWindows(seq, windowMethod, 1); foreach (var (actual, expected) in result.Zip(Enumerable.Range(0, 100))) actual.AssertSequenceEqual(expected); } } - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void TestWindowLargerThanSequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void TestWindowLargerThanSequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 101); + var result = GetWindows(seq, windowMethod, 101); result.AssertSequenceEqual(); } } - [Theory] - [MemberData(nameof(GetHundredElementSequences))] - public void TestWindowSmallerThanSequence(IDisposableEnumerable seq, WindowMethod wm) + [Test] + [MethodDataSource(nameof(GetHundredElementSequences))] + public void TestWindowSmallerThanSequence(IDisposableEnumerable seq, WindowMethod windowMethod) { using (seq) { - var result = GetWindows(seq, wm, 33); + var result = GetWindows(seq, windowMethod, 33); foreach (var (window, index) in result.Zip(Enumerable.Range(0, 100))) window.AssertSequenceEqual(Enumerable.Range(0, 100).Skip(index).Take(33)); } } - [Fact] + [Test] public void WindowListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/ZipLongestTest.cs b/Tests/SuperLinq.Tests/ZipLongestTest.cs similarity index 79% rename from Tests/SuperLinq.Test/ZipLongestTest.cs rename to Tests/SuperLinq.Tests/ZipLongestTest.cs index ac7b9a2cb..d244c1d3a 100644 --- a/Tests/SuperLinq.Test/ZipLongestTest.cs +++ b/Tests/SuperLinq.Tests/ZipLongestTest.cs @@ -1,7 +1,7 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ZipLongestTest { - [Fact] + [Test] public void ZipLongestIsLazy() { var bs = new BreakingSequence(); @@ -10,7 +10,7 @@ public void ZipLongestIsLazy() _ = bs.ZipLongest(bs, bs, bs, BreakingFunc.Of()); } - [Fact] + [Test] public void TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -19,32 +19,34 @@ public void TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() s1.ZipLongest(new BreakingSequence()).Consume()); } - public static IEnumerable GetTwoParamSequences() + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, int shortSeq)> GetTwoParamSequences() { - var parameters = new List + var parameters = new List<(IEnumerable seq1, IEnumerable seq2, int shortSeq)> { - new object[] { Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), 9 }, - new object[] { Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), 9 }, - new object[] { Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), 9 }, + (Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), 9), + (Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), 9), + (Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), 9), }; for (var i = 0; i < 2; i++) { var first = Enumerable.Range(1, 3 - (i == 0 ? 1 : 0)); var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [first.AsBreakingList(), second.AsBreakingList(), i,]); + (first.AsBreakingList(), second.AsBreakingList(), i) + ); + parameters.Add( - [first.AsTestingSequence(), second.AsTestingSequence(), i,]); -#pragma warning restore CA2000 // Dispose objects before losing scope + (first.AsTestingSequence(), second.AsTestingSequence(), i) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetTwoParamSequences))] + [Test] + [MethodDataSource(nameof(GetTwoParamSequences))] public void TwoParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, int shortSeq) { using (seq1 as IDisposableEnumerable) @@ -63,7 +65,7 @@ public void TwoParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, } } - [Fact] + [Test] public void TwoParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -88,7 +90,7 @@ public void TwoParamsListBehavior() #endif } - [Fact] + [Test] public void ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -98,38 +100,34 @@ public void ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() s1.ZipLongest(s2, new BreakingSequence()).Consume()); } - public static IEnumerable GetThreeParamSequences() + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, int shortSeq)> GetThreeParamSequences() { - var parameters = new List + var parameters = new List<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, int shortSeq)> { - new object[] - { + ( Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), - 9, - }, + 9 + ), }; for (var i = 0; i < 3; i++) @@ -137,29 +135,31 @@ public static IEnumerable GetThreeParamSequences() var first = Enumerable.Range(1, 3 - (i == 0 ? 1 : 0)); var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); var third = Enumerable.Range(1, 3 - (i == 2 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [ + ( first.AsBreakingList(), second.AsBreakingList(), third.AsBreakingList(), - i, - ]); + i + ) + ); + parameters.Add( - [ + ( first.AsTestingSequence(), second.AsTestingSequence(), third.AsTestingSequence(), - i, - ]); -#pragma warning restore CA2000 // Dispose objects before losing scope + i + ) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetThreeParamSequences))] + [Test] + [MethodDataSource(nameof(GetThreeParamSequences))] public void ThreeParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, int shortSeq) { using (seq1 as IDisposableEnumerable) @@ -180,7 +180,7 @@ public void ThreeParamsWorksProperly(IEnumerable seq1, IEnumerable seq } } - [Fact] + [Test] public void ThreeParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -205,7 +205,7 @@ public void ThreeParamsListBehavior() #endif } - [Fact] + [Test] public void FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -216,50 +216,57 @@ public void FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() s1.ZipLongest(s2, s3, new BreakingSequence()).Consume()); } - public static IEnumerable GetFourParamSequences() + public static IEnumerable<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + int shortSeq + )> GetFourParamSequences() { - var parameters = new List + var parameters = new List<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + int shortSeq + )> { - new object[] - { + ( Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), - 9, - }, - new object[] - { + 9 + ), + ( Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), - 9, - }, + 9 + ), }; for (var i = 0; i < 4; i++) @@ -268,32 +275,37 @@ public static IEnumerable GetFourParamSequences() var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); var third = Enumerable.Range(1, 3 - (i == 2 ? 1 : 0)); var fourth = Enumerable.Range(1, 3 - (i == 3 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [ + ( first.AsBreakingList(), second.AsBreakingList(), third.AsBreakingList(), fourth.AsBreakingList(), - i, - ]); + i + )); parameters.Add( - [ + ( first.AsTestingSequence(), second.AsTestingSequence(), third.AsTestingSequence(), fourth.AsTestingSequence(), - i, - ]); -#pragma warning restore CA2000 // Dispose objects before losing scope + i + )); } return parameters; } - [Theory] - [MemberData(nameof(GetFourParamSequences))] - public void FourParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, IEnumerable seq4, int shortSeq) + [Test] + [MethodDataSource(nameof(GetFourParamSequences))] + public void FourParamsWorksProperly( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + int shortSeq + ) { using (seq1 as IDisposableEnumerable) using (seq2 as IDisposableEnumerable) @@ -315,7 +327,7 @@ public void FourParamsWorksProperly(IEnumerable seq1, IEnumerable seq2 } } - [Fact] + [Test] public void FourParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); diff --git a/Tests/SuperLinq.Test/ZipMapTest.cs b/Tests/SuperLinq.Tests/ZipMapTest.cs similarity index 69% rename from Tests/SuperLinq.Test/ZipMapTest.cs rename to Tests/SuperLinq.Tests/ZipMapTest.cs index 8e2ceb0af..49b220494 100644 --- a/Tests/SuperLinq.Test/ZipMapTest.cs +++ b/Tests/SuperLinq.Tests/ZipMapTest.cs @@ -1,17 +1,17 @@ +using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Text.RegularExpressions; -namespace Test; +namespace SuperLinq.Tests; public sealed class ZipMapTest { - public static IEnumerable GetIntSequences() => + public static IEnumerable> GetIntSequences() => Enumerable.Range(1, 10) - .GetListSequences() - .Select(x => new object[] { x }); + .GetListSequences(); - [Theory] - [MemberData(nameof(GetIntSequences))] + [Test] + [MethodDataSource(nameof(GetIntSequences))] public void ZipMapIntTransformation(IDisposableEnumerable seq) { using (seq) @@ -22,16 +22,16 @@ public void ZipMapIntTransformation(IDisposableEnumerable seq) } } - public static IEnumerable GetStringSequences1() + public static IEnumerable<(IDisposableEnumerable seq, IEnumerable src)> GetStringSequences1() { var seq = Seq("foo", "bar", "FOO", "Bar", "baz", "QUx", "bAz", "QuX"); return seq .GetListSequences() - .Select(x => new object[] { x, seq }); + .Select(x => (x, seq)); } - [Theory] - [MemberData(nameof(GetStringSequences1))] + [Test] + [MethodDataSource(nameof(GetStringSequences1))] public void ZipMapStringTransformation(IDisposableEnumerable seq, IEnumerable src) { using (seq) @@ -42,13 +42,13 @@ public void ZipMapStringTransformation(IDisposableEnumerable seq, IEnume } } - public static IEnumerable GetStringSequences2() => - Seq("foo", "hello", "world", "Bar", "QuX", "ay", "az") - .GetListSequences() - .Select(x => new object[] { x }); - - [Theory] - [MemberData(nameof(GetStringSequences2))] + [Test] + [MethodDataSource( + typeof(TestExtensions), + nameof(TestExtensions.GetListSequences), + Arguments = [new[] { "foo", "hello", "world", "Bar", "QuX", "ay", "az" }] + )] + [SuppressMessage("Usage", "TUnit0001:Invalid Data for Tests")] public void ZipMapRegexChoose(IDisposableEnumerable seq) { using (seq) @@ -61,7 +61,7 @@ public void ZipMapRegexChoose(IDisposableEnumerable seq) } } - [Fact] + [Test] public void ZipMapListBehavior() { using var seq = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -76,7 +76,7 @@ public void ZipMapListBehavior() #endif } - [Fact] + [Test] public void ZipMapIsLazy() { var bs = new BreakingSequence(); diff --git a/Tests/SuperLinq.Test/ZipShortestTest.cs b/Tests/SuperLinq.Tests/ZipShortestTest.cs similarity index 79% rename from Tests/SuperLinq.Test/ZipShortestTest.cs rename to Tests/SuperLinq.Tests/ZipShortestTest.cs index 822f4e935..b6c3b5882 100644 --- a/Tests/SuperLinq.Test/ZipShortestTest.cs +++ b/Tests/SuperLinq.Tests/ZipShortestTest.cs @@ -1,7 +1,7 @@ -namespace Test; +namespace SuperLinq.Tests; public sealed class ZipShortestTest { - [Fact] + [Test] public void ZipShortestIsLazy() { var bs = new BreakingSequence(); @@ -10,7 +10,7 @@ public void ZipShortestIsLazy() _ = bs.ZipShortest(bs, bs, bs, BreakingFunc.Of()); } - [Fact] + [Test] public void MoveNextIsNotCalledUnnecessarily3() { using var s1 = TestingSequence.Of(1, 2); @@ -21,7 +21,7 @@ public void MoveNextIsNotCalledUnnecessarily3() s1.ZipShortest(s2, s3).Consume(); } - [Fact] + [Test] public void MoveNextIsNotCalledUnnecessarily4() { using var s1 = TestingSequence.Of(1, 2); @@ -38,7 +38,7 @@ public void MoveNextIsNotCalledUnnecessarily4() s1.ZipShortest(s2, s3, s4).Consume(); } - [Fact] + [Test] public void TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -47,32 +47,34 @@ public void TwoParamsDisposesInnerSequencesCaseGetEnumeratorThrows() s1.ZipShortest(new BreakingSequence()).Consume()); } - public static IEnumerable GetTwoParamSequences() + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, bool oneShort)> GetTwoParamSequences() { - var parameters = new List + var parameters = new List<(IEnumerable seq1, IEnumerable seq2, bool oneShort)> { - new object[] { Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), false }, - new object[] { Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), false }, - new object[] { Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), false }, + (Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), false), + (Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), false), + (Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), false), }; for (var i = 0; i < 2; i++) { var first = Enumerable.Range(1, 3 - (i == 0 ? 1 : 0)); var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [first.AsBreakingList(), second.AsBreakingList(), true,]); + (first.AsBreakingList(), second.AsBreakingList(), true) + ); + parameters.Add( - [first.AsTestingSequence(), second.AsTestingSequence(), true,]); -#pragma warning restore CA2000 // Dispose objects before losing scope + (first.AsTestingSequence(), second.AsTestingSequence(), true) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetTwoParamSequences))] + [Test] + [MethodDataSource(nameof(GetTwoParamSequences))] public void TwoParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, bool oneShort) { using (seq1 as IDisposableEnumerable) @@ -85,7 +87,7 @@ public void TwoParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, } } - [Fact] + [Test] public void TwoParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -110,7 +112,7 @@ public void TwoParamsListBehavior() #endif } - [Fact] + [Test] public void ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -120,38 +122,34 @@ public void ThreeParamsDisposesInnerSequencesCaseGetEnumeratorThrows() s1.ZipShortest(s2, new BreakingSequence()).Consume()); } - public static IEnumerable GetThreeParamSequences() + public static IEnumerable<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, bool oneShort)> GetThreeParamSequences() { - var parameters = new List + var parameters = new List<(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, bool oneShort)> { - new object[] - { + ( Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), - false, - }, + false + ), }; for (var i = 0; i < 3; i++) @@ -159,29 +157,31 @@ public static IEnumerable GetThreeParamSequences() var first = Enumerable.Range(1, 3 - (i == 0 ? 1 : 0)); var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); var third = Enumerable.Range(1, 3 - (i == 2 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [ + ( first.AsBreakingList(), second.AsBreakingList(), third.AsBreakingList(), - true, - ]); + true + ) + ); + parameters.Add( - [ + ( first.AsTestingSequence(), second.AsTestingSequence(), third.AsTestingSequence(), - true, - ]); -#pragma warning restore CA2000 // Dispose objects before losing scope + true + ) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetThreeParamSequences))] + [Test] + [MethodDataSource(nameof(GetThreeParamSequences))] public void ThreeParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, bool oneShort) { using (seq1 as IDisposableEnumerable) @@ -195,7 +195,7 @@ public void ThreeParamsWorksProperly(IEnumerable seq1, IEnumerable seq } } - [Fact] + [Test] public void ThreeParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList(); @@ -221,7 +221,7 @@ public void ThreeParamsListBehavior() #endif } - [Fact] + [Test] public void FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); @@ -232,50 +232,57 @@ public void FourParamsDisposesInnerSequencesCaseGetEnumeratorThrows() s1.ZipShortest(s2, s3, new BreakingSequence()).Consume()); } - public static IEnumerable GetFourParamSequences() + public static IEnumerable<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + bool oneShort + )> GetFourParamSequences() { - var parameters = new List + var parameters = new List<( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + bool oneShort + )> { - new object[] - { + ( Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).ToList(), Enumerable.Range(1, 3).AsTestingSequence(), - false, - }, - new object[] - { + false + ), + ( Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), Enumerable.Range(1, 3).AsBreakingList(), - false, - }, + false + ), }; for (var i = 0; i < 4; i++) @@ -284,32 +291,40 @@ public static IEnumerable GetFourParamSequences() var second = Enumerable.Range(1, 3 - (i == 1 ? 1 : 0)); var third = Enumerable.Range(1, 3 - (i == 2 ? 1 : 0)); var fourth = Enumerable.Range(1, 3 - (i == 3 ? 1 : 0)); -#pragma warning disable CA2000 // Dispose objects before losing scope + parameters.Add( - [ + ( first.AsBreakingList(), second.AsBreakingList(), third.AsBreakingList(), fourth.AsBreakingList(), - true, - ]); + true + ) + ); + parameters.Add( - [ + ( first.AsTestingSequence(), second.AsTestingSequence(), third.AsTestingSequence(), fourth.AsTestingSequence(), - true, - ]); -#pragma warning restore CA2000 // Dispose objects before losing scope + true + ) + ); } return parameters; } - [Theory] - [MemberData(nameof(GetFourParamSequences))] - public void FourParamsWorksProperly(IEnumerable seq1, IEnumerable seq2, IEnumerable seq3, IEnumerable seq4, bool oneShort) + [Test] + [MethodDataSource(nameof(GetFourParamSequences))] + public void FourParamsWorksProperly( + IEnumerable seq1, + IEnumerable seq2, + IEnumerable seq3, + IEnumerable seq4, + bool oneShort + ) { using (seq1 as IDisposableEnumerable) using (seq2 as IDisposableEnumerable) @@ -323,7 +338,7 @@ public void FourParamsWorksProperly(IEnumerable seq1, IEnumerable seq2 } } - [Fact] + [Test] public void FourParamsListBehavior() { using var seq1 = Enumerable.Range(0, 10_000).AsBreakingList();