Polina fedulova

CourseApp.Tests/Module_1/AplusBTest

@@ -0,0 +1,41 @@
+using System;
+using System.IO;
+using Xunit;
+using CourseApp.Module1;
+
+namespace CourseApp.Tests.Module1
+{
+    [Collection("Sequential")]
+    public class AplusBTest : IDisposable
+    {
+        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("10 12", "22")]
+        [InlineData("1 1", "2")]
+        [InlineData("10000 10000", "20000")]
+        public void Test1(string input, string expected)
+        {
+            var stringWriter = new StringWriter();
+            Console.SetOut(stringWriter);
+
+            var stringReader = new StringReader(input);
+            Console.SetIn(stringReader);
+
+            // act
+            AplusB.Calculate();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            Assert.Equal($"{expected}", output[0]);
+            var standardOutput = new StreamWriter(Console.OpenStandardOutput());
+        }
+    }
+}

CourseApp.Tests/Module_2/BubbleSortTest

@@ -0,0 +1,50 @@
+namespace CourseApp.Tests.Module2
+{
+    using System;
+    using System.IO;
+    using CourseApp.Module2;
+    using Xunit;
+
+    [Collection("Sequential")]
+    public class BubbleSortTest : IDisposable
+    {
+        private const string Inp1 = @"4
+4 3 2 1";
+
+        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()
+        {
+            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
+            BubbleSort.BubbleSortMethod();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}

CourseApp.Tests/Module_2/InversionCountTest

@@ -0,0 +1,53 @@
+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 = @"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
+            InversionCount.Start();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}
+

CourseApp.Tests/Module_2/MergeSortTest

@@ -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/Module_2/NumberDifTest

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

CourseApp.Tests/Module_2/PairSortTest

@@ -0,0 +1,61 @@
+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.PairSortMethod();
+
+            // assert
+            var output = stringWriter.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
+            var result = string.Join(Environment.NewLine, output);
+
+            Assert.Equal($"{expected}", result);
+        }
+    }
+}
+