public void TestWithAnEmptyCollection() { List<int> collection = new List<int>(); Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); Assert.AreEqual(0, collection.Count); }
public void QuickSortNullTest() { IList <int> arr = null; Quicksorter <int> sorter = new Quicksorter <int>(); sorter.Sort(arr); }
public void QuickSortZeroTest() { IList <int> arr = new List <int>(); Quicksorter <int> sorter = new Quicksorter <int>(); sorter.Sort(arr); }
public void TestQuickSortWithOneElement() { ISorter<int> sorter = new Quicksorter<int>(); collection.Items = new List<int>() { 1 }; collection.Sort(sorter); Assert.AreEqual(collection.Items[0], 1); }
public void QuickSortTestWithOneMemberArray() { Quicksorter<int> quicksorter = new Quicksorter<int>(); IList<int> list = new List<int>() { 1, }; IList<int> sortedList = new List<int>() { 1, }; quicksorter.Sort(list); Assert.AreEqual(string.Join(",", sortedList), string.Join(",", list)); }
public void QuickSortTestWithFilledArray() { Quicksorter<int> quicksorter = new Quicksorter<int>(); IList<int> list = new List<int>() { 9, 3, 2, 1, 4, 6, 5, 0, 8, 7 }; IList<int> sortedList = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; quicksorter.Sort(list); Assert.AreEqual(string.Join(",", sortedList), string.Join(",", list)); }
public void TestQuickSortShouldReturnCorrectElements() { ISorter<int> sorter = new Quicksorter<int>(); collection.Sort(sorter); Assert.AreEqual(collection.Items[0], 0); Assert.AreEqual(collection.Items[2], 22); Assert.AreEqual(collection.Items[collection.Items.Count - 1], 101); }
public void TestWithEmptyCollectionShouldReturnMissingElement() { var collection = new SortableCollection<int>(); var sorter = new Quicksorter<int>(); collection.Sort(sorter); var result = collection.InterpolationSearch(collection.ToArray(), 0); var expected = Array.BinarySearch(collection.ToArray(), 0); Assert.AreEqual(expected, result, "No elements are present in an empty collection; method should return -1."); }
public void AlreadySortedNumsTest() { List<int> quickSorter = new List<int>() { 1, 2, 3, 4, 5 }; Quicksorter<int> mergeSorter = new Quicksorter<int>(); List<int> expectedArray = new List<int>() { 1, 2, 3, 4, 5 }; mergeSorter.Sort(quickSorter); CollectionAssert.AreEqual(expectedArray, quickSorter); }
public void ReversedNumberSortTest() { List<int> arrayToSort = new List<int>() { 5, 4, 3, 2, 1 }; Quicksorter<int> quickSorter = new Quicksorter<int>(); List<int> expectedArray = new List<int>() { 1, 2, 3, 4, 5 }; quickSorter.Sort(arrayToSort); CollectionAssert.AreEqual(expectedArray, arrayToSort); }
public void SimpleQuickSortTest() { List<int> arrayToSort = new List<int>() { 2, 5, 3, 1, 4 }; Quicksorter<int> quickSorter = new Quicksorter<int>(); List<int> expectedArray = new List<int>() { 1, 2, 3, 4, 5 }; quickSorter.Sort(arrayToSort); CollectionAssert.AreEqual(expectedArray, arrayToSort); }
private void PopulateAndSort(Quicksorter <int> quicksorter) { quicksorter.Add(4); quicksorter.Add(5); quicksorter.Add(8); quicksorter.Add(6); quicksorter.Add(3); quicksorter.Add(7); quicksorter.Add(9); quicksorter.Sort(); }
public void TestWithASingleItem() { List<int> collection = new List<int>(); collection.Add(3); Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); Assert.AreEqual(1, collection.Count); Assert.AreEqual(3, collection[0]); }
public void TestWithItemToTheRightOfMidpoint() { var collection = new SortableCollection<int>(1, 2, 3, 4, 5); var sorter = new Quicksorter<int>(); collection.Sort(sorter); var result = collection.InterpolationSearch(collection.ToArray(), 4); var expected = Array.BinarySearch(collection.ToArray(), 4); Assert.AreEqual(expected, result); }
public void TestWithMissingElement() { var collection = new SortableCollection<int>(-1, 1, 5, 12, 50); var sorter = new Quicksorter<int>(); collection.Sort(sorter); var result = collection.InterpolationSearch(collection.ToArray(), 0); var expected = -1; Assert.AreEqual(expected, result, "Missing element should return -1."); }
public void SortShould_NotThrowIfTheCollectionIsEmpty_AndReturnEmptyCollection() { // Arange var sorter = new Quicksorter <string>(); var collection = new List <string>(0); // Act sorter.Sort(collection); // Assert Assert.AreEqual("", string.Join(", ", collection)); }
public void TestSortLengthOfCollection() { List<int> collection = new List<int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; int count = collection.Count; Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); Assert.AreEqual(count, collection.Count); }
internal static void Main(string[] args) { var collection = new SortableCollection<int>(new[] { 22, -2, 300, 11, 55, 33, 10, -15, 88, 101, 33, 0, 101, 44, 33 }); Console.WriteLine("All items before sorting:"); collection.PrintAllItemsOnConsole(); Console.WriteLine(); Console.WriteLine("SelectionSorter result:"); collection.Sort(new SelectionSorter<int>()); collection.PrintAllItemsOnConsole(); Console.WriteLine(); collection = new SortableCollection<int>(new[] { 22, -2, 300, 11, 55, 33, 10, -15, 88, 101, 33, 0, 101, 44, 33 }); Console.WriteLine("Quicksorter result:"); var quickSorter = new Quicksorter<int>(); collection.Sort(quickSorter); quickSorter.PrintResults(); //collection.PrintAllItemsOnConsole(); Console.WriteLine(); collection = new SortableCollection<int>(new[] { 22, -2, 300, 11, 55, 33, 10, -15, 88, 101, 33, 0, 101, 44, 33 }); Console.WriteLine("MergeSorter result:"); var mergeSort = new MergeSorter<int>(); collection.Sort(mergeSort); mergeSort.ShowResults(); //collection.PrintAllItemsOnConsole(); Console.WriteLine(); Console.WriteLine("Linear search 101:"); Console.WriteLine(collection.LinearSearch(101)); Console.WriteLine(); Console.WriteLine("Binary search 101:"); Console.WriteLine(collection.BinarySearch(101)); Console.WriteLine(); collection = new SortableCollection<int>(new int[20]); for (int i = 1; i <= 20; i++) { collection.Items[i - 1] = i; } Console.WriteLine("All items before sorting:"); collection.PrintAllItemsOnConsole(); Console.WriteLine("Shuffle:"); collection.Shuffle(); collection.PrintAllItemsOnConsole(); Console.WriteLine(); Console.WriteLine("Shuffle again:"); collection.Shuffle(); collection.PrintAllItemsOnConsole(); }
public void TestSortLengthOfCollection() { List <int> collection = new List <int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; int count = collection.Count; Quicksorter <int> sorter = new Quicksorter <int>(); sorter.Sort(collection); Assert.AreEqual(count, collection.Count); }
public void TestWithTwoItems() { List<int> collection = new List<int>(); collection.Add(3); collection.Add(0); Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); Assert.AreEqual(2, collection.Count); Assert.AreEqual(0, collection[0]); Assert.AreEqual(3, collection[1]); }
public static void Main(string[] args) { Random R = new Random(42); for (int i = 10000000;; i += 3) { int[] A = new int[i]; int[] B = new int[i]; for (int j = 0; j < i; ++j) { int v = R.Next(); A[j] = (v); B[j] = (v); } Stopwatch sw = new Stopwatch(); sw.Start(); Quicksorter <int> .init(); Quicksorter <int> .qs(A, 0, A.Length, (int x, int y) => { return(x - y); } ); lock (Quicksorter <int> .lck){ while (Quicksorter <int> .done == false) { Monitor.Wait(Quicksorter <int> .lck); } } sw.Stop(); Console.WriteLine(sw.Elapsed); Array.Sort(B, 0, B.Length); for (int j = 0; j < A.Length; ++j) { if (A[j] != B[j]) { throw new Exception("Mismatch"); } } if (i > 0) { break; } } Console.WriteLine("OK"); }
public void QuickSortSortedTest() { var arr = new List <int>() { 0, 11, 22, 33, 101, 101 }; Quicksorter <int> sorter = new Quicksorter <int>(); sorter.Sort(arr); var expected = new List <int>() { 0, 11, 22, 33, 101, 101 }; CollectionAssert.AreEqual(arr, expected); }
public void SortShould_SortThePassedCollectionOfIntegers() { // Arange var sorter = new Quicksorter <int>(); var collection = new List <int>() { 2, 1, 4, 5, 6, 3 }; var result = "1, 2, 3, 4, 5, 6"; // Act sorter.Sort(collection); // Assert Assert.AreEqual(result, string.Join(", ", collection)); }
public void SortShould_SortThePassedCollectionOfStrings() { // Arange var sorter = new Quicksorter <string>(); var collection = new List <string>() { "2", "1", "4", "5", "6", "3" }; var result = "1, 2, 3, 4, 5, 6"; // Act sorter.Sort(collection); // Assert Assert.AreEqual(result, string.Join(", ", collection)); }
public void QuickSort_ShouldSortGivenCollectionProperly_WithStrings() { var sorter = new Quicksorter <string>(); var testedCollection = new SortableCollection <string>(new[] { "Ivan", "Petyr", "Gosho", "Pencho", "Dragan" }); testedCollection.Sort(sorter); var result = new StringBuilder(); for (int i = 0; i < testedCollection.Items.Count; i++) { result.Append(testedCollection.Items[i]); result.Append(" "); } var expectedResult = "Dragan Gosho Ivan Pencho Petyr "; Assert.AreEqual(expectedResult, result.ToString()); }
public void TestSortIsSortedWithListSort() { List<int> collection = new List<int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); List<int> collection2 = new List<int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; collection2.Sort(); CollectionAssert.AreEqual(collection2, collection); }
public void TestWithOddNumberOfItems() { List<int> collection = new List<int>(); collection.Add(3); collection.Add(0); collection.Add(11); collection.Add(-3); collection.Add(5); collection.Add(0); collection.Add(4); Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); Assert.AreEqual(7, collection.Count); Assert.IsTrue(SortableCollection<int>.IsSorted(collection)); }
public void QuickSort_ShouldSortGivenCollectionProperly_WithNumbers() { var sorter = new Quicksorter <int>(); var testedCollection = new SortableCollection <int>(new[] { 22, 11, 101, 33, 0, 101 }); testedCollection.Sort(sorter); var result = new StringBuilder(); for (int i = 0; i < testedCollection.Items.Count; i++) { result.Append(testedCollection.Items[i]); result.Append(" "); } var expectedResult = "0 11 22 33 101 101 "; Assert.AreEqual(expectedResult, result.ToString()); }
public void TestSortIsSortedWithListSort() { List <int> collection = new List <int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; Quicksorter <int> sorter = new Quicksorter <int>(); sorter.Sort(collection); List <int> collection2 = new List <int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; collection2.Sort(); CollectionAssert.AreEqual(collection2, collection); }
public void TestSortIsSortedWithCheck() { List<int> collection = new List<int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); bool isSorted = true; for (int i = 0; i < collection.Count - 1; i++) { if (collection[i] > collection[i + 1]) { isSorted = false; } } Assert.IsTrue(isSorted); }
public void TestSortIsSortedWithCheck() { List <int> collection = new List <int>() { 3, 5, 21, 543, 2, 12, 3, 65, 34, 234, 23, 12, 3, 43, 12, 32, 341, 24, 23 }; Quicksorter <int> sorter = new Quicksorter <int>(); sorter.Sort(collection); bool isSorted = true; for (int i = 0; i < collection.Count - 1; i++) { if (collection[i] > collection[i + 1]) { isSorted = false; } } Assert.IsTrue(isSorted); }
public void TestStringQuicksorter_RandomNumberOfItems() { ISorter<string> sorter = new Quicksorter<string>(); TestsHelper.TestStringSorter(sorter); }
public void TestWithMultipleMissingKeysSmallerThanMinimum() { const int NumberOfChecks = 10000; const int NumberOfElements = 1000; var elements = new int[NumberOfElements]; for (int i = 0; i < NumberOfElements; i++) { elements[i] = Random.Next(int.MinValue / 2, int.MaxValue / 2); } Array.Sort(elements); var collection = new SortableCollection<int>(elements); var sorter = new Quicksorter<int>(); collection.Sort(sorter); var sortedArray = collection.ToArray(); for (int i = 0; i < NumberOfChecks; i++) { var item = Random.Next(int.MinValue, collection.Items[0]); var result = collection.InterpolationSearch(sortedArray, item); Assert.AreEqual(-1, result); } }
public void TestQuicksorterWhenCollectionIsNull_ThrowsException() { ISorter <int> sorter = new Quicksorter <int>(); TestsHelper.TestInt32SorterWhenCollectionIsNull(sorter); }
public void TestWithANullCollection() { List<int> collection = null; Quicksorter<int> sorter = new Quicksorter<int>(); sorter.Sort(collection); }
public void QuicksortTest() { IQuicksorter quicksorter = new Quicksorter(); RunTests(quicksorter); }
public static void InitilizeQuickSorter(TestContext context) { sorter = new Quicksorter<int>(); }
public void TestInt32Quicksorter_RandomNumberOfItems() { ISorter <int> sorter = new Quicksorter <int>(); TestsHelper.TestInt32Sorter(sorter); }
public void TestStringQuicksorter_RandomNumberOfItems() { ISorter <string> sorter = new Quicksorter <string>(); TestsHelper.TestStringSorter(sorter); }
public void TestQuicksorterWhenCollectionIsNull_ThrowsException() { ISorter<int> sorter = new Quicksorter<int>(); TestsHelper.TestInt32SorterWhenCollectionIsNull(sorter); }
public override IEnumerable <TElement> Sort(IEnumerable <TElement> collection, IComparer <TElement> comparer, bool parallel) { var quicksorter = new Quicksorter(collection, comparer, parallel); return(quicksorter.Sort()); }
public void TestInt32Quicksorter_RandomNumberOfItems() { ISorter<int> sorter = new Quicksorter<int>(); TestsHelper.TestInt32Sorter(sorter); }