Module 2

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/BubbleSortTest.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Linq;
+using System.Text;
 using Xunit;
 using CourseApp.Module2;
 
@@ -8,11 +10,25 @@ namespace CourseApp.Tests.Module2
     [Collection("Sequential")]
     public class BubbleSortTest : IDisposable
     {
-        private const string Inp1 = @"7
-5 1 7 3 9 4 1";
+        private const string Inp1 = "4 3 2 1 10";
 
-        private const string Inp2 = @"3
--10 7 2";
+        private const string Inp2 = "4 3 2 1";
+
+        private const string Out1 = @"3 4 2 1 10
+3 2 4 1 10
+3 2 1 4 10
+2 3 1 4 10
+2 1 3 4 10
+1 2 3 4 10
+";
+
+        private const string Out2 = @"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,22 +40,19 @@ public void Dispose()
         }
 
         [Theory]
-        [InlineData(Inp1, "1 1 3 4 5 7 9")]
-        [InlineData(Inp2, "-10 2 7")]
-        public void Test1(string input, string expected)
+        [InlineData(Inp1, Out1)]
+        [InlineData(Inp2, Out2)]
+        public void Checking_BubbleSort_Works_Correctly(string input, string expected)
         {
-            var stringWriter = new StringWriter();
-            Console.SetOut(stringWriter);
-
-            var stringReader = new StringReader(input);
-            Console.SetIn(stringReader);
-
             // act
-            BubbleSort.BubbleSortMethod();
+            int[] buffer = input.Split(' ').Select(int.Parse).ToArray();
+
+            BubbleSort.BubbleSortMethod(buffer);
 
             // assert
-            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
-            Assert.Equal($"{expected}", output[0]);
+            var output = File.ReadAllText("output.txt");
+            Assert.Equal($"{expected}", output);
+            File.Delete("output.txt");
         }
     }
-}
+}

CourseApp.Tests/Module2/CountUniqueTest.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Text;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class CountUniqueTest : IDisposable
+    {
+        private const string Inp1 = @"5
+1 0 1 2 0";
+
+        private const string Inp2 = @"5
+0 0 0 0 0";
+
+        private const string Out1 = @"3
+";
+
+        private const string Out2 = @"1
+";
+
+        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 Checking_Counting_Works_Correctly(string input, string expected)
+        {
+            // act
+            StreamWriter write = new StreamWriter("input.txt");
+            write.WriteLine(input);
+            write.Close();
+
+            CountUnique.DoCount();
+
+            // assert
+            var output = File.ReadAllText("output.txt");
+            Assert.Equal($"{expected}", output);
+            File.Delete("input.txt");
+            File.Delete("output.txt");
+        }
+    }
+}

CourseApp.Tests/Module2/InversionTest.cs

@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Text;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class InversionTest : IDisposable
+    {
+        private const string Inp1 = @"2
+3 1";
+
+        private const string Inp2 = @"5
+5 4 3 2 1";
+
+        private const string Out1 = @"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 Checking_Invesrion_Count_Correctly(string input, string expected)
+        {
+            // act
+            StreamWriter write = new StreamWriter("input.txt");
+            write.WriteLine(input);
+            write.Close();
+
+            Inversion.CountInversions();
+
+            // assert
+            var output = File.ReadAllText("output.txt");
+            Assert.Equal($"{expected}", output);
+            File.Delete("input.txt");
+            File.Delete("output.txt");
+        }
+    }
+}

CourseApp.Tests/Module2/MergeSortTest.cs

@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+using System.Text;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class MergeSortTest : IDisposable
+    {
+        private const string Inp1 = @"2
+3 1";
+
+        private const string Inp2 = @"5
+5 4 3 2 1";
+
+        private const string Out1 = @"1 2 1 3
+1 3
+";
+
+        private const string Out2 = @"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)]
+        public void Checking_MergeSort_Works_Correctly(string input, string expected)
+        {
+            // act
+            StreamWriter write = new StreamWriter("input.txt");
+            write.WriteLine(input);
+            write.Close();
+
+            MergeSort.DoMergeSort();
+
+            // assert
+            var output = File.ReadAllText("output.txt");
+            Assert.Equal($"{expected}", output);
+            File.Delete("input.txt");
+            File.Delete("output.txt");
+        }
+    }
+}

CourseApp.Tests/Module2/PairSortTest.cs

@@ -0,0 +1,51 @@
+using System;
+using System.IO;
+using System.Linq;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class PairSortTest : IDisposable
+    {
+        private const string Inp1 = @"101 80
+305 90
+200 14";
+
+        private const string Inp2 = @"25 90
+20 90
+30 90";
+
+        private const string Out1 = @"305 90
+101 80
+200 14";
+
+        private const string Out2 = @"20 90
+25 90
+30 90";
+
+        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 Checking_PairSort_Works_Correctly(string input, string expected)
+        {
+            // act
+            string[] testingData = input.Split(Environment.NewLine).ToArray();
+
+            string answer = string.Join(Environment.NewLine, PairSort.PairBubbleSortMethod(testingData));
+
+            // assert
+            Assert.Equal($"{expected}", answer);
+        }
+    }
+}

CourseApp.Tests/Module2/PurchaseTest.cs

@@ -0,0 +1,51 @@
+using System;
+using System.IO;
+using System.Text;
+using Xunit;
+using CourseApp.Module2;
+
+namespace CourseApp.Tests.Module2
+{
+    [Collection("Sequential")]
+    public class PurchaseTest : IDisposable
+    {
+        private const string Inp1 = @"5
+1 50 3 4 3
+16
+1 2 3 4 5 1 3 3 4 5 5 5 5 5 4 5";
+
+        private const string Out1 = @"yes
+no
+no
+no
+yes
+";
+
+        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 Checking_Counting_Works_Correctly(string input, string expected)
+        {
+            // act
+            StreamWriter write = new StreamWriter("input.txt");
+            write.WriteLine(input);
+            write.Close();
+
+            Purchase.CountPurcase();
+
+            // assert
+            var output = File.ReadAllText("output.txt");
+            Assert.Equal($"{expected}", output);
+            File.Delete("input.txt");
+            File.Delete("output.txt");
+        }
+    }
+}