Added Bubble Sort

CourseApp.Tests/CourseApp.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
     <NoWarn>1573,1591,1701;1702;1705</NoWarn>
     <IsPackable>false</IsPackable>

CourseApp.Tests/Module2/BubblePairSortTest.cs

@@ -0,0 +1,58 @@
+using System;
+using System.IO;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class BubblePairSortTest : IDisposable
+    {
+        private const string Inp1 = @"3
+190 76
+299 86
+191 26";
+
+        private const string Out1 = @"299 86
+190 76
+191 26";
+
+        private const string Inp2 = @"3
+1 3
+3 4
+2 4";
+
+        private const string Out2 = @"2 4
+3 4
+1 3";
+
+        public void Dispose()
+        {
+            var standardOut = new StreamWriter(Console.OpenStandardOutput());
+            standardOut.AutoFlush = true;
+            var standardIn = new StreamReader(Console.OpenStandardInput());
+            Console.SetOut(standardOut);
+            Console.SetIn(standardIn);
+        }
+
+        [Theory]
+        [InlineData(Inp1, Out1)]
+        [InlineData(Inp2, Out2)]
+        public void Test1(string input, string expected)
+        {
+            var stringWriter = new StringWriter();
+            Console.SetOut(stringWriter);
+
+            var stringReader = new StringReader(input);
+            Console.SetIn(stringReader);
+
+            // act
+            BubblePairSort.BubblePairSortMethod();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module2/BubbleSortTest.cs

@@ -11,8 +11,22 @@ public class BubbleSortTest : IDisposable
         private const string Inp1 = @"7
 5 1 7 3 9 4 1";
 
+        private const string Out1 = @"1 5 7 3 9 4 1
+1 5 3 7 9 4 1
+1 5 3 7 4 9 1
+1 5 3 7 4 1 9
+1 3 5 7 4 1 9
+1 3 5 4 7 1 9
+1 3 5 4 1 7 9
+1 3 4 5 1 7 9
+1 3 4 1 5 7 9
+1 3 1 4 5 7 9
+1 1 3 4 5 7 9";
+
         private const string Inp2 = @"3
--10 7 2";
+-10 2 7";
+
+        private const string Out2 = @"0";
 
         public void Dispose()
         {
@@ -24,8 +38,8 @@ public void Dispose()
         }
 
         [Theory]
-        [InlineData(Inp1, "1 1 3 4 5 7 9")]
-        [InlineData(Inp2, "-10 2 7")]
+        [InlineData(Inp1, Out1)]
+        [InlineData(Inp2, Out2)]
         public void Test1(string input, string expected)
         {
             var stringWriter = new StringWriter();
@@ -39,7 +53,8 @@ public void Test1(string input, string expected)
 
             // assert
             var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
-            Assert.Equal($"{expected}", output[0]);
+            var result = string.Join(Environment.NewLine, output);
+            Assert.Equal($"{expected}", result);
         }
     }
 }

CourseApp.Tests/Module2/MergeSortTest.cs

@@ -0,0 +1,61 @@
+using System;
+using System.IO;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class MergeSortTest : IDisposable
+    {
+        private const string Inp1 = @"1
+1";
+
+        private const string Out1 = @"1";
+
+        private const string Inp2 = @"2
+3 1";
+
+        private const string Out2 = @"1 2 1 3
+1 3";
+
+        private const string Inp3 = @"5
+5 4 3 2 1";
+
+        private const string Out3 = @"1 2 4 5
+4 5 1 2
+3 5 1 3
+1 5 1 5
+1 2 3 4 5";
+
+        public void Dispose()
+        {
+            var standardOut = new StreamWriter(Console.OpenStandardOutput());
+            standardOut.AutoFlush = true;
+            var standardIn = new StreamReader(Console.OpenStandardInput());
+            Console.SetOut(standardOut);
+            Console.SetIn(standardIn);
+        }
+
+        [Theory]
+        [InlineData(Inp1, Out1)]
+        [InlineData(Inp2, Out2)]
+        [InlineData(Inp3, Out3)]
+        public void Test1(string input, string expected)
+        {
+            var stringWriter = new StringWriter();
+            Console.SetOut(stringWriter);
+
+            var stringReader = new StringReader(input);
+            Console.SetIn(stringReader);
+
+            // act
+            MergeSort.MergeSortMethod();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module2/NumDiffSortTest.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using CourseApp.Module2;
+using Xunit;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+
+    public class NumDiffSortTest : IDisposable
+    {
+        private const string Inp1 = @"5
+1 0 1 2 0";
+
+        private const string Out1 = @"3";
+
+        public void Dispose()
+        {
+            var standardOut = new StreamWriter(Console.OpenStandardOutput());
+            standardOut.AutoFlush = true;
+            var standardIn = new StreamReader(Console.OpenStandardInput());
+            Console.SetOut(standardOut);
+            Console.SetIn(standardIn);
+        }
+
+        [Theory]
+        [InlineData(Inp1, Out1)]
+        public void Test1(string input, string expected)
+        {
+            var stringWriter = new StringWriter();
+            Console.SetOut(stringWriter);
+
+            var stringReader = new StringReader(input);
+            Console.SetIn(stringReader);
+
+            // act
+            NumDiff.NumDifferent();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module2/NumInversSortTest.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using CourseApp.Module2;
+using Xunit;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class NumInversSortTest : IDisposable
+    {
+        private const string Inp1 = @"1
+1";
+
+        private const string Out1 = @"0";
+
+        private const string Inp2 = @"5
+5 4 3 2 1";
+
+        private const string Out2 = @"10";
+
+        public void Dispose()
+        {
+            var standardOut = new StreamWriter(Console.OpenStandardOutput());
+            standardOut.AutoFlush = true;
+            var standardIn = new StreamReader(Console.OpenStandardInput());
+            Console.SetOut(standardOut);
+            Console.SetIn(standardIn);
+        }
+
+        [Theory]
+        [InlineData(Inp1, Out1)]
+        [InlineData(Inp2, Out2)]
+        public void Test1(string input, string expected)
+        {
+            var stringWriter = new StringWriter();
+            Console.SetOut(stringWriter);
+
+            var stringReader = new StringReader(input);
+            Console.SetIn(stringReader);
+
+            // act
+            NumInvers.NumInversion();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module2/RadixSortTest.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using CourseApp.Module2;
+using Xunit;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+
+    public class RadixSortTest : IDisposable
+    {
+        private const string Inp1 = @"9
+12
+32
+45
+67
+98
+29
+61
+35
+09";
+
+        private const string Out1 = @"Initial array:
+12, 32, 45, 67, 98, 29, 61, 35, 09
+**********
+Phase 1
+Bucket 0: empty
+Bucket 1: 61
+Bucket 2: 12, 32
+Bucket 3: empty
+Bucket 4: empty
+Bucket 5: 45, 35
+Bucket 6: empty
+Bucket 7: 67
+Bucket 8: 98
+Bucket 9: 29, 09
+**********
+Phase 2
+Bucket 0: 09
+Bucket 1: 12
+Bucket 2: 29
+Bucket 3: 32, 35
+Bucket 4: 45
+Bucket 5: empty
+Bucket 6: 61, 67
+Bucket 7: empty
+Bucket 8: empty
+Bucket 9: 98
+**********
+Sorted array:
+09, 12, 29, 32, 35, 45, 61, 67, 98";
+
+        public void Dispose()
+        {
+            var standardOut = new StreamWriter(Console.OpenStandardOutput());
+            standardOut.AutoFlush = true;
+            var standardIn = new StreamReader(Console.OpenStandardInput());
+            Console.SetOut(standardOut);
+            Console.SetIn(standardIn);
+        }
+
+        [Theory]
+        [InlineData(Inp1, Out1)]
+        public void Test1(string input, string expected)
+        {
+            var stringWriter = new StringWriter();
+            Console.SetOut(stringWriter);
+
+            var stringReader = new StringReader(input);
+            Console.SetIn(stringReader);
+
+            // act
+            RadixSort.RadixSortMethod();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}