rework all

SORTER.sln

@@ -5,7 +5,7 @@ VisualStudioVersion = 17.0.32014.148
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SORTER", "SORTER\SORTER.csproj", "{2734C2E0-DAEA-4312-A462-7A4F20593CA9}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestSorter", "TestSorter\TestSorter.csproj", "{E5723B14-9CFD-479E-8AAA-35DEBAA8E042}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SortertTest", "SortertTest\SortertTest.csproj", "{93A8BB01-7340-490F-8110-D09F0861235C}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -17,10 +17,10 @@ Global
 		{2734C2E0-DAEA-4312-A462-7A4F20593CA9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2734C2E0-DAEA-4312-A462-7A4F20593CA9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2734C2E0-DAEA-4312-A462-7A4F20593CA9}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E5723B14-9CFD-479E-8AAA-35DEBAA8E042}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E5723B14-9CFD-479E-8AAA-35DEBAA8E042}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E5723B14-9CFD-479E-8AAA-35DEBAA8E042}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E5723B14-9CFD-479E-8AAA-35DEBAA8E042}.Release|Any CPU.Build.0 = Release|Any CPU
+		{93A8BB01-7340-490F-8110-D09F0861235C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{93A8BB01-7340-490F-8110-D09F0861235C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{93A8BB01-7340-490F-8110-D09F0861235C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{93A8BB01-7340-490F-8110-D09F0861235C}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

SORTER/MainWindow.xaml.cs

@@ -26,11 +26,6 @@ namespace SORTER
         int[] array;
         string path;
         FileInfo file;
-        Stopwatch linearTime;
-        Stopwatch minMaxTime;
-        Stopwatch bubleTime;
-        Stopwatch shuttleTime;
-        Stopwatch insertionTime;
 
         public MainWindow()
         {
@@ -38,346 +33,51 @@ namespace SORTER
         }
 
 
-        bool writeFile(string pathCopy, int[] arraySorted)
+        bool writeFile(string nameFile, int[] arraySorted)
         {
-            using (StreamWriter sw = new StreamWriter(pathCopy, false))
-            {
-                for (int i = 0; i < arraySorted.Length; ++i)
-                {
-                    sw.Write(arraySorted[i] + " ");
-                }
-            }
-
-            return true;
-        }
-
-        (int[], string) linearSelectionSort(bool? ordering)
-        {
-            int[] arraySorted = new int[array.Length];
-            int[] arrayCopy = new int[array.Length];
-
-            int max = int.MinValue;
-            int min = int.MaxValue;
-            int index = 0;
-
-            for (int i = 0; i < arrayCopy.Length; ++i)
-            {
-                arrayCopy[i] = array[i];
-            }
-
-            string pathCopy = file.DirectoryName + @"\Линейная сортировка.txt";
-            if (!File.Exists(pathCopy))
-            {
-                File.Copy(path, pathCopy);
-            }
-
-            linearTime = new Stopwatch();
-            linearTime.Start();
 
-            if (ordering == false)
+            try
             {
-                while (arraySorted.Length < arrayCopy.Length)
+                string pathCopy = pathCopied(nameFile);
+                using (StreamWriter sw = new StreamWriter(pathCopy, false))
                 {
-                    for (int i = 0; i < arrayCopy.Length; ++i)
+                    for (int i = 0; i < arraySorted.Length; ++i)
                     {
-                        if (max <= arrayCopy[i] && arrayCopy[i] != 100)
-                        {
-                            max = arrayCopy[i];
-                            index = i;
-                        }
+                        sw.Write(arraySorted[i] + " ");
                     }
-                    arrayCopy[index] = 100;
-                    arraySorted.Append(max);
-                    max = int.MinValue;
                 }
             }
-            else
+            catch
             {
-                while (arraySorted.Length < arrayCopy.Length)
-                {
-                    for (int i = 0; i < arrayCopy.Length; ++i)
-                    {
-                        if (min >= arrayCopy[i] && arrayCopy[i] != 100)
-                        {
-                            min = arrayCopy[i];
-                            index = i;
-                        }
-                    }
-                    arrayCopy[index] = 100;
-                    arraySorted.Append(min);
-                    min = int.MaxValue;
-                }  
+                MessageBox.Show("Ошибка записи");
+                return false;
             }
-
-            linearTime.Stop();
-            return (arraySorted, pathCopy);
-        }
-
-
-        void methodMinMax(bool? ordering)
-        {
-
-            int[] arrayCopy = new int[array.Length];
-
-            for (int i = 0; i < arrayCopy.Length; ++i)
-            {
-                arrayCopy[i] = array[i];
-            }
-
-            minMaxTime = new Stopwatch();
-            minMaxTime.Start();
-
-            if(ordering == false)
-            {
-                for (int i = 0; i < arrayCopy.Length - 1; ++i)
-                {
-                    int max = i;
-
-                    for (int j = i + 1; j < arrayCopy.Length; ++j)
-                    {
-                        if (arrayCopy[j].CompareTo(arrayCopy[max]) > 0)
-                        {
-                            max = j;
-                        }
-                    }
-
-                    int temp = array[i];
-                    arrayCopy[i] = array[max];
-                    arrayCopy[max] = temp;
-                }
-
-            }
-            else
-            {
-                for (int i = 0; i < arrayCopy.Length - 1; ++i)
-                {
-                    int max = i;
-
-                    for (int j = i + 1; j < arrayCopy.Length; ++j)
-                    {
-                        if (arrayCopy[j].CompareTo(arrayCopy[max]) < 0)
-                        {
-                            max = j;
-                        }
-                    }
-
-                    int temp = arrayCopy[i];
-                    arrayCopy[i] = arrayCopy[max];
-                    arrayCopy[max] = temp;
-                }
-
-            }
-
-            minMaxTime.Stop();
-
-            string pathCopy = file.DirectoryName + @"\МинМакс.txt";
-            if(!File.Exists(pathCopy))
-            {
-                File.Copy(path, pathCopy);
-            }
-
-            writeFile(pathCopy, arrayCopy);
+            return true;
         }
 
-
-        void BubbleSort(bool? ordering)
+        string pathCopied(string nameFile)
         {
+            string pathCopy = file.DirectoryName + nameFile;
 
-            int[] arrayCopy = new int[array.Length];
-
-            for (int i = 0; i < arrayCopy.Length; ++i)
-            {
-                arrayCopy[i] = array[i];
-            }
-
-            int temp;
-
-            bubleTime = new Stopwatch();
-            bubleTime.Start();
-
-            if (ordering == false)
-            {
-                for (int i = 0; i < arrayCopy.Length - 1; i++)
-                {
-                    for (int j = 0; j < arrayCopy.Length - i - 1; j++)
-                    {
-                        if (arrayCopy[j + 1] > arrayCopy[j])
-                        {
-                            temp = arrayCopy[j + 1];
-                            arrayCopy[j + 1] = arrayCopy[j];
-                            arrayCopy[j] = temp;
-                        }
-                    }
-                }
-            }
-            else
-            {
-                for (int i = 0; i < arrayCopy.Length - 1; i++)
-                {
-                    for (int j = 0; j < arrayCopy.Length - i - 1; j++)
-                    {
-                        if (arrayCopy[j + 1] < arrayCopy[j])
-                        {
-                            temp = arrayCopy[j + 1];
-                            arrayCopy[j + 1] = arrayCopy[j];
-                            arrayCopy[j] = temp;
-                        }
-                    }
-                }
-            }
-
-            bubleTime.Stop();
-
-            string pathCopy = file.DirectoryName + @"\Пузырьковая сортировка.txt";
             if (!File.Exists(pathCopy))
             {
                 File.Copy(path, pathCopy);
             }
 
-            writeFile(pathCopy, arrayCopy);
+            return pathCopy;
         }
 
-
-        void ShuttleSort(bool? ordering)
+        int[] arrayCopied()
         {
-
             int[] arrayCopy = new int[array.Length];
-
             for (int i = 0; i < arrayCopy.Length; ++i)
             {
                 arrayCopy[i] = array[i];
             }
-
-            int temp;
-
-            shuttleTime = new Stopwatch();
-            shuttleTime.Start();
-
-            if(ordering == false)
-            {
-                for (int i = 1; i < arrayCopy.Length; i++)
-                {
-                    if (arrayCopy[i] > arrayCopy[i - 1])
-                    {
-                        temp = arrayCopy[i];
-                        arrayCopy[i] = arrayCopy[i - 1];
-                        arrayCopy[i - 1] = temp;
-                        for (int j = i - 1; (j - 1) >= 0; j--)
-                        {
-                            if (arrayCopy[j] > arrayCopy[j - 1])
-                            {
-                                temp = arrayCopy[j];
-                                arrayCopy[j] = arrayCopy[j - 1];
-                                arrayCopy[j - 1] = temp;
-                            }
-                            else
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            else
-            {
-                for (int i = 1; i < arrayCopy.Length; i++)
-                {
-                    if (arrayCopy[i] < arrayCopy[i - 1])
-                    {
-                        temp = arrayCopy[i];
-                        arrayCopy[i] = arrayCopy[i - 1];
-                        arrayCopy[i - 1] = temp;
-                        for (int j = i - 1; (j - 1) >= 0; j--)
-                        {
-                            if (arrayCopy[j] < arrayCopy[j - 1])
-                            {
-                                temp = arrayCopy[j];
-                                arrayCopy[j] = arrayCopy[j - 1];
-                                arrayCopy[j - 1] = temp;
-                            }
-                            else
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-
-            shuttleTime.Stop();
-
-            string pathCopy = file.DirectoryName + @"\Челночная сортировка.txt";
-            if (!File.Exists(pathCopy))
-            {
-                File.Copy(path, pathCopy);
-            }
-
-            writeFile(pathCopy, arrayCopy);
+            return arrayCopy;
         }
 
-
-        void InsertionSort(bool? ordering)
-        {
-
-            int[] arrayCopy = new int[array.Length];
-
-            for (int i = 0; i < arrayCopy.Length; ++i)
-            {
-                arrayCopy[i] = array[i];
-            }
-
-            int index, temp;
-
-            insertionTime = new Stopwatch();
-            insertionTime.Start();
-
-            if (ordering == false)
-            {
-                for (int i = 0; i < arrayCopy.Length; ++i)
-                {
-                    index = i;
-                    temp = arrayCopy[i];
-                    for (int j = i + 1; j < arrayCopy.Length; ++j)
-                    {
-                        if (arrayCopy[j] > temp)
-                        {
-                            index = j;
-                            temp = arrayCopy[j];
-                        }
-                    }
-                    arrayCopy[index] = arrayCopy[i];
-                    arrayCopy[i] = temp;
-                }
-            }
-            else
-            {
-                for (int i = 0; i < arrayCopy.Length; ++i)
-                {
-                    index = i;
-                    temp = arrayCopy[i];
-                    for (int j = i + 1; j < arrayCopy.Length; ++j)
-                    {
-                        if (arrayCopy[j] < temp)
-                        {
-                            index = j;
-                            temp = arrayCopy[j];
-                        }
-                    }
-                    arrayCopy[index] = arrayCopy[i];
-                    arrayCopy[i] = temp;
-                }
-            }
-
-            insertionTime.Stop();
-
-            string pathCopy = file.DirectoryName + @"\Сортировка вставки.txt";
-            if (!File.Exists(pathCopy))
-            {
-                File.Copy(path, pathCopy);
-            }
-
-            writeFile(pathCopy, arrayCopy);
-        }
+       
 
         private void SortButton_Click(object sender, RoutedEventArgs e)
         {
@@ -389,24 +89,28 @@ namespace SORTER
             {
                 if (LinearButton.IsChecked == true)
                 {
-                    (int[] array, string pathCopy) = linearSelectionSort(Ascending.IsChecked);
-                    writeFile(pathCopy, array);
+                    int[] arraySorted = sortClass.linearSelectionSort(Ascending.IsChecked, arrayCopied());
+                    writeFile(@"\Линейный выбор.txt", arraySorted);
                 }
                 else if (minMaxButton.IsChecked == true)
                 {
-                    methodMinMax(Ascending.IsChecked);
+                    int[] arraySorted = sortClass.methodMinMax(Ascending.IsChecked, arrayCopied());
+                    writeFile(@"\МинМакс.txt", arraySorted);
                 }
                 else if (BubbleButton.IsChecked == true)
                 {
-                    BubbleSort(Ascending.IsChecked);
+                    int[] arraySorted = sortClass.BubbleSort(Ascending.IsChecked, arrayCopied());
+                    writeFile(@"\Пузырьковая сортировка.txt", arraySorted);
                 }
                 else if (ShuttleButton.IsChecked == true)
                 {
-                    ShuttleSort(Ascending.IsChecked);
+                    int[] arraySorted = sortClass.ShuttleSort(Ascending.IsChecked, arrayCopied());
+                    writeFile(@"\Челночная сортировка.txt", arraySorted);
                 }
                 else if (InsertionButton.IsChecked == true)
                 {
-                    InsertionSort(Ascending.IsChecked);
+                    int[] arraySorted = sortClass.InsertionSort(Ascending.IsChecked, arrayCopied());
+                    writeFile(@"\Сортировка вставки.txt", arraySorted);
                 }
 
                 MessageBox.Show("Массив отсортирован, файл с ним находится рядом с выбранным файлом");
@@ -448,13 +152,13 @@ namespace SORTER
 
         private void Diagram_Click(object sender, RoutedEventArgs e)
         {
-            if (linearTime == null || minMaxTime == null || bubleTime == null || shuttleTime == null || insertionTime == null)
+            if (sortClass.linearTime == null || sortClass.minMaxTime == null || sortClass.bubleTime == null || sortClass.shuttleTime == null || sortClass.insertionTime == null)
             {
                 MessageBox.Show("Для того, чтобы построить диаграмму, нужно отсортировать массив всеми способами");
             }
             else
             {
-                Diagram wnd = new Diagram(linearTime.ElapsedTicks, minMaxTime.ElapsedTicks, bubleTime.ElapsedTicks, shuttleTime.ElapsedTicks, insertionTime.ElapsedTicks);
+                Diagram wnd = new Diagram(sortClass.linearTime.ElapsedTicks, sortClass.minMaxTime.ElapsedTicks, sortClass.bubleTime.ElapsedTicks, sortClass.shuttleTime.ElapsedTicks, sortClass.insertionTime.ElapsedTicks);
                 wnd.Show();
             }
         }

SORTER/sortClass.cs

@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SORTER
+{
+    public class sortClass
+    {
+        public static Stopwatch linearTime;
+        public static Stopwatch minMaxTime;
+        public static Stopwatch bubleTime;
+        public static Stopwatch shuttleTime;
+        public static Stopwatch insertionTime;
+
+        public static int[] linearSelectionSort(bool? ordering, int[] arrayCopy)
+        {
+            int[] arraySorted = new int[arrayCopy.Length];
+
+            int max = int.MinValue;
+            int min = int.MaxValue;
+            int index = 0;
+            int count;
+
+            linearTime = new Stopwatch();
+            linearTime.Start();
+
+            if (ordering == false)
+            {
+                count = 0;
+                while (count < arrayCopy.Length)
+                {
+                    for (int i = 0; i < arrayCopy.Length; ++i)
+                    {
+                        if (max <= arrayCopy[i] && arrayCopy[i] != 100)
+                        {
+                            max = arrayCopy[i];
+                            index = i;
+                        }
+                    }
+                    arrayCopy[index] = 100;
+                    arraySorted[count] = max;
+                    count++;
+                    max = int.MinValue;
+                }
+            }
+            else
+            {
+                count = 0;
+                while (count < arrayCopy.Length)
+                {
+                    for (int i = 0; i < arrayCopy.Length; ++i)
+                    {
+                        if (min >= arrayCopy[i] && arrayCopy[i] != 100)
+                        {
+                            min = arrayCopy[i];
+                            index = i;
+                        }
+                    }
+                    arrayCopy[index] = 100;
+                    arraySorted[count] = min;
+                    count++;
+                    min = int.MaxValue;
+                }
+            }
+
+            linearTime.Stop();
+            return arraySorted;
+        }
+
+
+        public static int[] methodMinMax(bool? ordering, int[] arrayCopy)
+        {
+
+            minMaxTime = new Stopwatch();
+            minMaxTime.Start();
+
+            if (ordering == false)
+            {
+                for (int i = 0; i < arrayCopy.Length - 1; ++i)
+                {
+                    int max = i;
+
+                    for (int j = i + 1; j < arrayCopy.Length; ++j)
+                    {
+                        if (arrayCopy[j].CompareTo(arrayCopy[max]) > 0)
+                        {
+                            max = j;
+                        }
+                    }
+
+                    int temp = arrayCopy[i];
+                    arrayCopy[i] = arrayCopy[max];
+                    arrayCopy[max] = temp;
+                }
+
+            }
+            else
+            {
+                for (int i = 0; i < arrayCopy.Length - 1; ++i)
+                {
+                    int max = i;
+
+                    for (int j = i + 1; j < arrayCopy.Length; ++j)
+                    {
+                        if (arrayCopy[j].CompareTo(arrayCopy[max]) < 0)
+                        {
+                            max = j;
+                        }
+                    }
+
+                    int temp = arrayCopy[i];
+                    arrayCopy[i] = arrayCopy[max];
+                    arrayCopy[max] = temp;
+                }
+
+            }
+
+            minMaxTime.Stop();
+            return arrayCopy;
+        }
+
+
+        public static int[] BubbleSort(bool? ordering, int[] arrayCopy)
+        {
+
+            int temp;
+
+            bubleTime = new Stopwatch();
+            bubleTime.Start();
+
+            if (ordering == false)
+            {
+                for (int i = 0; i < arrayCopy.Length - 1; i++)
+                {
+                    for (int j = 0; j < arrayCopy.Length - i - 1; j++)
+                    {
+                        if (arrayCopy[j + 1] > arrayCopy[j])
+                        {
+                            temp = arrayCopy[j + 1];
+                            arrayCopy[j + 1] = arrayCopy[j];
+                            arrayCopy[j] = temp;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < arrayCopy.Length - 1; i++)
+                {
+                    for (int j = 0; j < arrayCopy.Length - i - 1; j++)
+                    {
+                        if (arrayCopy[j + 1] < arrayCopy[j])
+                        {
+                            temp = arrayCopy[j + 1];
+                            arrayCopy[j + 1] = arrayCopy[j];
+                            arrayCopy[j] = temp;
+                        }
+                    }
+                }
+            }
+
+            bubleTime.Stop();
+            return arrayCopy;
+        }
+
+
+        public static int[] ShuttleSort(bool? ordering, int[] arrayCopy)
+        {
+            int temp;
+
+            shuttleTime = new Stopwatch();
+            shuttleTime.Start();
+
+            if (ordering == false)
+            {
+                for (int i = 1; i < arrayCopy.Length; i++)
+                {
+                    if (arrayCopy[i] > arrayCopy[i - 1])
+                    {
+                        temp = arrayCopy[i];
+                        arrayCopy[i] = arrayCopy[i - 1];
+                        arrayCopy[i - 1] = temp;
+                        for (int j = i - 1; (j - 1) >= 0; j--)
+                        {
+                            if (arrayCopy[j] > arrayCopy[j - 1])
+                            {
+                                temp = arrayCopy[j];
+                                arrayCopy[j] = arrayCopy[j - 1];
+                                arrayCopy[j - 1] = temp;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 1; i < arrayCopy.Length; i++)
+                {
+                    if (arrayCopy[i] < arrayCopy[i - 1])
+                    {
+                        temp = arrayCopy[i];
+                        arrayCopy[i] = arrayCopy[i - 1];
+                        arrayCopy[i - 1] = temp;
+                        for (int j = i - 1; (j - 1) >= 0; j--)
+                        {
+                            if (arrayCopy[j] < arrayCopy[j - 1])
+                            {
+                                temp = arrayCopy[j];
+                                arrayCopy[j] = arrayCopy[j - 1];
+                                arrayCopy[j - 1] = temp;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            shuttleTime.Stop();
+            return arrayCopy;
+        }
+
+
+        public static int[] InsertionSort(bool? ordering, int[] arrayCopy)
+        {
+
+            int index, temp;
+
+            insertionTime = new Stopwatch();
+            insertionTime.Start();
+
+            if (ordering == false)
+            {
+                for (int i = 0; i < arrayCopy.Length; ++i)
+                {
+                    index = i;
+                    temp = arrayCopy[i];
+                    for (int j = i + 1; j < arrayCopy.Length; ++j)
+                    {
+                        if (arrayCopy[j] > temp)
+                        {
+                            index = j;
+                            temp = arrayCopy[j];
+                        }
+                    }
+                    arrayCopy[index] = arrayCopy[i];
+                    arrayCopy[i] = temp;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < arrayCopy.Length; ++i)
+                {
+                    index = i;
+                    temp = arrayCopy[i];
+                    for (int j = i + 1; j < arrayCopy.Length; ++j)
+                    {
+                        if (arrayCopy[j] < temp)
+                        {
+                            index = j;
+                            temp = arrayCopy[j];
+                        }
+                    }
+                    arrayCopy[index] = arrayCopy[i];
+                    arrayCopy[i] = temp;
+                }
+            }
+
+            insertionTime.Stop();
+            return arrayCopy;
+        }
+    }
+}

SortertTest/SortertTest.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0-windows</TargetFramework>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.7" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.7" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SORTER\SORTER.csproj" />
+  </ItemGroup>
+
+</Project>

SortertTest/UnitTest1.cs

@@ -0,0 +1,90 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SORTER;
+using System.Linq;
+
+namespace TestSorter
+{
+    [TestClass]
+    public class UnitTest1
+    {
+
+        [TestMethod]
+        public void TestLinear ()
+        {
+            int[] arrayAsc = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            int[] arrayUnSortedAsc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedAsc = sortClass.linearSelectionSort(true, arrayUnSortedAsc);
+            Assert.IsTrue(arrayAsc.SequenceEqual(arraySortedAsc));
+
+
+            int[] arrayDesc = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+            int[] arrayUnSortedDesc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedDesc = sortClass.linearSelectionSort(false, arrayUnSortedDesc);
+            Assert.IsTrue(arrayDesc.SequenceEqual(arraySortedDesc));
+        }
+
+
+        [TestMethod]
+        public void TestMinMax()
+        {
+            int[] arrayAsc = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            int[] arrayUnSortedAsc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedAsc = sortClass.methodMinMax(true, arrayUnSortedAsc);
+            Assert.IsTrue(arrayAsc.SequenceEqual(arraySortedAsc));
+
+
+            int[] arrayDesc = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+            int[] arrayUnSortedDesc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedDesc = sortClass.methodMinMax(false, arrayUnSortedDesc);
+            Assert.IsTrue(arrayDesc.SequenceEqual(arraySortedDesc));
+        }
+
+
+        [TestMethod]
+        public void TestBubble()
+        {
+            int[] arrayAsc = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            int[] arrayUnSortedAsc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedAsc = sortClass.BubbleSort(true, arrayUnSortedAsc);
+            Assert.IsTrue(arrayAsc.SequenceEqual(arraySortedAsc));
+
+
+            int[] arrayDesc = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+            int[] arrayUnSortedDesc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedDesc = sortClass.BubbleSort(false, arrayUnSortedDesc);
+            Assert.IsTrue(arrayDesc.SequenceEqual(arraySortedDesc));
+        }
+
+
+        [TestMethod]
+        public void TestShuttle()
+        {
+            int[] arrayAsc = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            int[] arrayUnSortedAsc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedAsc = sortClass.ShuttleSort(true, arrayUnSortedAsc);
+            Assert.IsTrue(arrayAsc.SequenceEqual(arraySortedAsc));
+
+
+            int[] arrayDesc = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+            int[] arrayUnSortedDesc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedDesc = sortClass.ShuttleSort(false, arrayUnSortedDesc);
+            Assert.IsTrue(arrayDesc.SequenceEqual(arraySortedDesc));
+        }
+
+
+        [TestMethod]
+        public void TestInsertion()
+        {
+            int[] arrayAsc = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            int[] arrayUnSortedAsc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedAsc = sortClass.InsertionSort(true, arrayUnSortedAsc);
+            Assert.IsTrue(arrayAsc.SequenceEqual(arraySortedAsc));
+
+
+            int[] arrayDesc = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+            int[] arrayUnSortedDesc = { 2, 1, 3, 4, 8, 5, 10, 7, 9, 6 };
+            int[] arraySortedDesc = sortClass.InsertionSort(false, arrayUnSortedDesc);
+            Assert.IsTrue(arrayDesc.SequenceEqual(arraySortedDesc));
+        }
+    }
+}

TestSorter/TestSorter.csproj

@@ -1,27 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net6.0-windows</TargetFramework>
-    <Nullable>enable</Nullable>
-
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.0">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\SORTER\SORTER.csproj" />
-  </ItemGroup>
-
-</Project>

TestSorter/UnitTest1.cs

@@ -1,15 +0,0 @@
-using Xunit;
-using SORTER;
-
-namespace TestSorter
-{
-    public class UnitTest1
-    {
-        [Fact]
-        public void Test1()
-        {
-            int[] array = new int[] { 3, 2, 3 };
-            Assert.Equal(1, 1);
-        }
-    }
-}