Update README.md

CourseApp.Tests/Module2/BubbleSortTest.cs

@@ -1,18 +1,22 @@
-using System;
-using System.IO;
-using Xunit;
-using CourseApp.Module2;
-
-namespace CourseApp.Tests.Module2
+namespace CourseApp.Tests.Module2
 {
+    using System;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
     [Collection("Sequential")]
     public class BubbleSortTest : IDisposable
     {
-        private const string Inp1 = @"7
-5 1 7 3 9 4 1";
+        private const string Inp1 = @"4
+4 3 2 1";
 
-        private const string Inp2 = @"3
--10 7 2";
+        private const string Out1 = @"3 4 2 1
+3 2 4 1
+3 2 1 4
+2 3 1 4
+2 1 3 4
+1 2 3 4";
 
         public void Dispose()
         {
@@ -24,8 +28,7 @@ public void Dispose()
         }
 
         [Theory]
-        [InlineData(Inp1, "1 1 3 4 5 7 9")]
-        [InlineData(Inp2, "-10 2 7")]
+        [InlineData(Inp1, Out1)]
         public void Test1(string input, string expected)
         {
             var stringWriter = new StringWriter();
@@ -35,11 +38,13 @@ public void Test1(string input, string expected)
             Console.SetIn(stringReader);
 
             // act
-            BubbleSort.BubbleSortMethod();
+            BubbleSort.SortOff();
 
             // 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/DifferentCountTest.cs

@@ -0,0 +1,45 @@
+namespace CourseApp.Tests.Module2
+{
+    using System;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
+    [Collection("Sequential")]
+    public class DifferentCountTest : 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
+            DifferentCount.CountDifferent();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module2/InversionCountTest.cs

@@ -0,0 +1,56 @@
+namespace CourseApp.Tests.Module2
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
+    [Collection("Sequential")]
+    public class InversionCountTest : IDisposable
+    {
+        private const string Inp1 = @"1
+1";
+
+        private const string Out1 = @"0";
+
+        private const string Inp2 = @"2
+3 1";
+
+        private const string Out2 = @"1";
+
+        private const string Inp3 = @"5
+5 4 3 2 1";
+
+        private const string Out3 = @"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(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
+            InversionCount.CountInversion();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module2/MergeSortTest.cs

@@ -0,0 +1,63 @@
+namespace CourseApp.Tests.Module2
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
+    [Collection("Sequential")]
+    public class MergeSortTest : IDisposable
+    {
+        private const string Inp1 = @"5
+5 4 3 2 1";
+
+        private const string Out1 = @"1 2 4 5
+4 5 1 2
+3 5 1 3
+1 5 1 5
+1 2 3 4 5";
+
+        private const string Inp2 = @"1
+1";
+
+        private const string Out2 = @"1";
+
+        private const string Inp3 = @"2
+3 1";
+
+        private const string Out3 = @"1 2 1 3
+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)]
+        [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/PairSortTest.cs

@@ -0,0 +1,60 @@
+namespace CourseApp.Tests.Module2
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
+    [Collection("Sequential")]
+    public class PairSortTest : IDisposable
+    {
+        private const string Inp1 = @"3
+20 80
+30 90
+25 90";
+
+        private const string Out1 = @"25 90
+30 90
+20 80";
+
+        private const string Inp2 = @"3
+101 80
+305 90
+200 14";
+
+        private const string Out2 = @"305 90
+101 80
+200 14";
+
+        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
+            PairSort.PairSortMetod();
+
+            // 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,82 @@
+namespace CourseApp.Tests.Module2
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
+    [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.Try();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}