Modernize C# codebase with collection expressions (C# 12) (#539)

Copilot · web-flow · commit 7467fe4ea0d2 · 2025-10-06T00:11:06.000+03:00
diff --git a/Algorithms.Tests/Sequences/DivisorsCountSequenceTests.cs b/Algorithms.Tests/Sequences/DivisorsCountSequenceTests.cs
@@ -8,17 +8,17 @@ public class DivisorsCountSequenceTests
     public void First10ElementsCorrect()
     {
         // These values are taken from https://oeis.org/A000005 for comparison.
-        var oeisSource = new BigInteger[]
-                         {
-                             1,  2, 2, 3,  2,  4,  2,  4,  3, 4, 2,  6, 2,
-                             4,  4, 5, 2,  6,  2,  6,  4,  4, 2, 8,  3, 4,
-                             4,  6, 2, 8,  2,  6,  4,  4,  4, 9, 2,  4, 4,
-                             8,  2, 8, 2,  6,  6,  4,  2, 10, 3, 6,  4, 6,
-                             2,  8, 4, 8,  4,  4,  2, 12,  2, 4, 6,  7, 4,
-                             8,  2, 6, 4,  8,  2, 12,  2,  4, 6, 6,  4, 8,
-                             2, 10, 5, 4,  2, 12,  4,  4,  4, 8, 2, 12, 4,
-                             6,  4, 4, 4, 12,  2,  6,  6,  9, 2, 8,  2, 8,
-                         };
+        BigInteger[] oeisSource =
+        [
+            1,  2, 2, 3,  2,  4,  2,  4,  3, 4, 2,  6, 2,
+            4,  4, 5, 2,  6,  2,  6,  4,  4, 2, 8,  3, 4,
+            4,  6, 2, 8,  2,  6,  4,  4,  4, 9, 2,  4, 4,
+            8,  2, 8, 2,  6,  6,  4,  2, 10, 3, 6,  4, 6,
+            2,  8, 4, 8,  4,  4,  2, 12,  2, 4, 6,  7, 4,
+            8,  2, 6, 4,  8,  2, 12,  2,  4, 6, 6,  4, 8,
+            2, 10, 5, 4,  2, 12,  4,  4,  4, 8, 2, 12, 4,
+            6,  4, 4, 4, 12,  2,  6,  6,  9, 2, 8,  2, 8,
+        ];
 
         var sequence = new DivisorsCountSequence().Sequence.Take(oeisSource.Length);
         sequence.SequenceEqual(oeisSource).Should().BeTrue();
diff --git a/Algorithms.Tests/Sequences/EulerTotientSequenceTests.cs b/Algorithms.Tests/Sequences/EulerTotientSequenceTests.cs
@@ -11,8 +11,8 @@ public void FirstElementsCorrect()
         //  Initial test of 69 number from table at https://oeis.org/A000010/list and passed test.
         //  Extended out to 500 values from https://primefan.tripod.com/Phi500.html and passed initial 69
         // along with remaining values.
-        var check = new BigInteger[]
-                    {
+        BigInteger[] check =
+        [
                         1,     1,   2,   2,   4,   2,   6,   4,   6,   4,  10,   4,  12,   6,   8,   8,  16,   6,  18,   8,
                         12,   10,  22,   8,  20,  12,  18,  12,  28,   8,  30,  16,  20,  16,  24,  12,  36,  18,  24,  16,
                         40,   12,  42,  20,  24,  22,  46,  16,  42,  20,  32,  24,  52,  18,  40,  24,  36,  28,  58,  16,
@@ -38,7 +38,7 @@ public void FirstElementsCorrect()
                         252, 192, 442, 144, 352, 222, 296, 192, 448, 120, 400, 224, 300, 226, 288, 144, 456, 228, 288, 176,
                         460, 120, 462, 224, 240, 232, 466, 144, 396, 184, 312, 232, 420, 156, 360, 192, 312, 238, 478, 128,
                         432, 240, 264, 220, 384, 162, 486, 240, 324, 168, 490, 160, 448, 216, 240, 240, 420, 164, 498, 200,
-                    };
+        ];
 
         var sequence = new EulerTotientSequence().Sequence.Take(check.Length);
         sequence.SequenceEqual(check).Should().BeTrue();
diff --git a/Algorithms.Tests/Sequences/FibonacciSequenceTests.cs b/Algorithms.Tests/Sequences/FibonacciSequenceTests.cs
@@ -8,7 +8,8 @@ public class FibonacciSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new FibonacciSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 })
+        BigInteger[] expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }
diff --git a/Algorithms.Tests/Sequences/KolakoskiSequenceTests.cs b/Algorithms.Tests/Sequences/KolakoskiSequenceTests.cs
@@ -8,8 +8,8 @@ public class KolakoskiSequenceTests
     public void First100ElementsCorrect()
     {
         // Taken from https://oeis.org/A000002
-        var expected = new BigInteger[]
-        {
+        BigInteger[] expected =
+        [
             1, 2, 2, 1, 1, 2, 1, 2, 2, 1,
             2, 2, 1, 1, 2, 1, 1, 2, 2, 1,
             2, 1, 1, 2, 1, 2, 2, 1, 1, 2,
@@ -20,7 +20,7 @@ public void First100ElementsCorrect()
             1, 2, 1, 2, 2, 1, 2, 1, 1, 2,
             2, 1, 2, 2, 1, 1, 2, 1, 2, 2,
             1, 2, 2, 1, 1, 2, 1, 1, 2, 2,
-        };
+        ];
 
         var sequence = new KolakoskiSequence().Sequence.Take(100);
         var sequence2 = new KolakoskiSequence2().Sequence.Take(100);
diff --git a/Algorithms.Tests/Sequences/NaturalSequenceTests.cs b/Algorithms.Tests/Sequences/NaturalSequenceTests.cs
@@ -8,7 +8,8 @@ public class NaturalSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new NaturalSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 })
+        BigInteger[] expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }
diff --git a/Algorithms.Tests/Sequences/NegativeIntegersSequenceTests.cs b/Algorithms.Tests/Sequences/NegativeIntegersSequenceTests.cs
@@ -8,7 +8,8 @@ public class NegativeIntegersSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new NegativeIntegersSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 })
+        BigInteger[] expected = [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }
diff --git a/Algorithms.Tests/Sequences/PowersOf2SequenceTests.cs b/Algorithms.Tests/Sequences/PowersOf2SequenceTests.cs
@@ -8,7 +8,8 @@ public class PowersOf2SequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new PowersOf2Sequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 })
+        BigInteger[] expected = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }
diff --git a/Algorithms.Tests/Sequences/SquaresSequenceTests.cs b/Algorithms.Tests/Sequences/SquaresSequenceTests.cs
@@ -8,7 +8,8 @@ public class SquaresSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new SquaresSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 })
+        BigInteger[] expected = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }
diff --git a/Algorithms.Tests/Sequences/TetranacciNumbersSequenceTests.cs b/Algorithms.Tests/Sequences/TetranacciNumbersSequenceTests.cs
@@ -8,12 +8,13 @@ public class TetranacciNumbersSequenceTests
     public void First35ElementsCorrect()
     {
         var sequence = new TetranacciNumbersSequence().Sequence.Take(35);
-        sequence.SequenceEqual(new BigInteger[]
-            {
-                1, 1, 1, 1, 4, 7, 13, 25, 49, 94, 181, 349, 673, 1297, 2500, 4819, 9289, 17905, 34513, 66526, 128233,
-                247177, 476449, 918385, 1770244, 3412255, 6577333, 12678217, 24438049, 47105854, 90799453, 175021573,
-                337364929, 650291809, 1253477764,
-            })
+        BigInteger[] expected =
+        [
+            1, 1, 1, 1, 4, 7, 13, 25, 49, 94, 181, 349, 673, 1297, 2500, 4819, 9289, 17905, 34513, 66526, 128233,
+            247177, 476449, 918385, 1770244, 3412255, 6577333, 12678217, 24438049, 47105854, 90799453, 175021573,
+            337364929, 650291809, 1253477764,
+        ];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }
diff --git a/Algorithms.Tests/Sequences/VanEcksSequenceTests.cs b/Algorithms.Tests/Sequences/VanEcksSequenceTests.cs
@@ -8,14 +8,14 @@ public class VanEcksSequenceTests
     public void First50ElementsCorrect()
     {
         // Taken from http://oeis.org/A181391
-        var expected = new BigInteger[]
-        {
+        BigInteger[] expected =
+        [
             0, 0, 1, 0, 2, 0, 2, 2, 1, 6,
             0, 5, 0, 2, 6, 5, 4, 0, 5, 3,
             0, 3, 2, 9, 0, 4, 9, 3, 6, 14,
             0, 6, 3, 5, 15, 0, 5, 3, 5, 2,
             17, 0, 6, 11, 0, 3, 8, 0, 3, 3,
-        };
+        ];
 
         var sequence = new VanEcksSequence().Sequence.Take(50);
 
diff --git a/DataStructures.Tests/Stack/ListBasedStackTests.cs b/DataStructures.Tests/Stack/ListBasedStackTests.cs
@@ -7,22 +7,22 @@ public static class ListBasedStackTests
     [Test]
     public static void CountTest()
     {
-        var stack = new ListBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
+        var stack = new ListBasedStack<int>([0, 1, 2, 3, 4]);
         stack.Count.Should().Be(5);
     }
 
     [Test]
     public static void ClearTest()
     {
-        var stack = new ListBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
+        var stack = new ListBasedStack<int>([0, 1, 2, 3, 4]);
         stack.Clear();
         stack.Count.Should().Be(0);
     }
 
     [Test]
     public static void ContainsTest()
     {
-        var stack = new ListBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
+        var stack = new ListBasedStack<int>([0, 1, 2, 3, 4]);
 
         Assert.Multiple(() =>
         {
@@ -37,7 +37,7 @@ public static void ContainsTest()
     [Test]
     public static void PeekTest()
     {
-        var stack = new ListBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
+        var stack = new ListBasedStack<int>([0, 1, 2, 3, 4]);
 
         Assert.Multiple(() =>
         {
@@ -50,7 +50,7 @@ public static void PeekTest()
     [Test]
     public static void PopTest()
     {
-        var stack = new ListBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
+        var stack = new ListBasedStack<int>([0, 1, 2, 3, 4]);
 
         Assert.Multiple(() =>
         {

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,8 @@ public class FibonacciSequenceTests`
`8`	`8`	`public void First10ElementsCorrect()`
`9`	`9`	`{`
`10`	`10`	`var sequence = new FibonacciSequence().Sequence.Take(10);`
`11`		`- sequence.SequenceEqual(new BigInteger[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 })`
	`11`	`+ BigInteger[] expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34];`
	`12`	`+ sequence.SequenceEqual(expected)`
`12`	`13`	`.Should().BeTrue();`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,8 @@ public class NaturalSequenceTests`
`8`	`8`	`public void First10ElementsCorrect()`
`9`	`9`	`{`
`10`	`10`	`var sequence = new NaturalSequence().Sequence.Take(10);`
`11`		`- sequence.SequenceEqual(new BigInteger[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 })`
	`11`	`+ BigInteger[] expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];`
	`12`	`+ sequence.SequenceEqual(expected)`
`12`	`13`	`.Should().BeTrue();`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,8 @@ public class NegativeIntegersSequenceTests`
`8`	`8`	`public void First10ElementsCorrect()`
`9`	`9`	`{`
`10`	`10`	`var sequence = new NegativeIntegersSequence().Sequence.Take(10);`
`11`		`- sequence.SequenceEqual(new BigInteger[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 })`
	`11`	`+ BigInteger[] expected = [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10];`
	`12`	`+ sequence.SequenceEqual(expected)`
`12`	`13`	`.Should().BeTrue();`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,8 @@ public class PowersOf2SequenceTests`
`8`	`8`	`public void First10ElementsCorrect()`
`9`	`9`	`{`
`10`	`10`	`var sequence = new PowersOf2Sequence().Sequence.Take(10);`
`11`		`- sequence.SequenceEqual(new BigInteger[] { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 })`
	`11`	`+ BigInteger[] expected = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512];`
	`12`	`+ sequence.SequenceEqual(expected)`
`12`	`13`	`.Should().BeTrue();`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,8 @@ public class SquaresSequenceTests`
`8`	`8`	`public void First10ElementsCorrect()`
`9`	`9`	`{`
`10`	`10`	`var sequence = new SquaresSequence().Sequence.Take(10);`
`11`		`- sequence.SequenceEqual(new BigInteger[] { 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 })`
	`11`	`+ BigInteger[] expected = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81];`
	`12`	`+ sequence.SequenceEqual(expected)`
`12`	`13`	`.Should().BeTrue();`
`13`	`14`	`}`
`14`	`15`	`}`