public void TestBinarySearch_WithNonExistingItem()
{
var collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
var result = collection.LinearSearch(-11);
Assert.AreNotEqual(true, result);
}
private void LoadShippingMethods(Order o)
{
var rates = new SortableCollection <ShippingRateDisplay>();
if (!o.HasShippingItems)
{
var r = new ShippingRateDisplay
{
DisplayName = GlobalLocalization.GetString("NoShippingRequired"),
ProviderId = string.Empty,
ProviderServiceCode = string.Empty,
Rate = 0,
ShippingMethodId = "NOSHIPPING"
};
rates.Add(r);
}
else
{
// Shipping Methods
rates = HccApp.OrderServices.FindAvailableShippingRates(o);
if (rates.Count < 1)
{
var result = new ShippingRateDisplay();
result.DisplayName = GlobalLocalization.GetString("ToBeDetermined");
result.ShippingMethodId = "TOBEDETERMINED";
result.Rate = 0;
rates.Add(result);
}
}
litShippingMethods.Text = HtmlRendering.ShippingRatesToRadioButtons(rates, 300, o.ShippingMethodUniqueKey);
}
static void Main()
{
var collection = new SortableCollection <int>(new[] { 22, 11, 101, 33, 0, 101 });
Console.WriteLine("All items before sorting:");
Console.WriteLine(collection);
Console.WriteLine("SelectionSorter result:");
collection.Sort(new SelectionSorter <int>());
Console.WriteLine(collection);
Console.WriteLine("Quicksorter result:");
collection.Sort(new Quicksorter <int>());
Console.WriteLine(collection);
Console.WriteLine("MergeSorter result:");
collection.Sort(new MergeSorter <int>());
Console.WriteLine(collection);
Console.WriteLine("Linear search 101:");
Console.WriteLine(collection.LinearSearch(101));
Console.WriteLine("Binary search 101:");
Console.WriteLine(collection.BinarySearch(101));
Console.WriteLine("Shuffle:");
collection.Shuffle();
Console.WriteLine(collection);
Console.WriteLine("Shuffle again:");
collection.Shuffle();
Console.WriteLine(collection);
}
public void TestSelectionSortingWithEmptyCollection()
{
var collection = new SortableCollection<int>();
collection.Sort(new SelectionSorter<int>());
Assert.AreEqual(0, collection.Items.Count, "Collection is not empty after sorting");
}
public void TestLinearSearchWithExistingElementInMiddlePositionOddCountOfElements()
{
var collection = new SortableCollection<int>(new[] { 49, 101, 33, 22, 11, 0, 17 });
var result = collection.LinearSearch(22);
Assert.IsTrue(result, "Element not found");
}
public void TestSortWithMultipleRandomElements()
{
for (int i = 0; i < NumberOfTests; i++)
{
int numberOfElements = Random.Next(MinNumberOfElementsToSort, MaxNumberOfElementsToSort + 1);
int maxValue = Random.Next(MaxValueCeiling);
int[] elements = new int[numberOfElements];
for (int j = 0; j < numberOfElements; j++)
{
elements[j] = Random.Next(maxValue);
}
var collection = new SortableCollection <int>(elements);
collection.Sort(new BucketSorter {
Max = maxValue
});
Array.Sort(elements);
/*collection.Sort(new BucketSorter { Max = maxValue });*/
CollectionAssert.AreEqual(elements, collection.ToArray());
}
}
public static void Main(string[] args)
{
const int NumberOfElementsToSort = 22;
const int MaxValue = 150;
var array = new int[NumberOfElementsToSort];
for (int i = 0; i < NumberOfElementsToSort; i++)
{
array[i] = Random.Next(MaxValue);
}
var collectionToSort = new SortableCollection<int>(array);
collectionToSort.Sort(new BucketSorter { Max = MaxValue });
Console.WriteLine(collectionToSort);
var collection = new SortableCollection<int>(2, -1, 5, 0, -3);
collection = new SortableCollection<int>(3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48);
Console.WriteLine(collection);
collection.Shuffle();
Console.WriteLine(collection);
//collection.Sort(new Quicksorter<int>());
//Console.WriteLine(collection);
}
public static void Main()
{
List<int> numbers = new List<int>() {1,3,4,6,7,8,9,10,23,42};
SortableCollection<int> sortableCollection = new SortableCollection<int>(numbers);
Console.WriteLine(sortableCollection.BinarySearch(-12));
}
public void TestWithASingleItemNotFound()
{
SortableCollection<int> collection = new SortableCollection<int>(new int[] { 6 });
bool isFound = collection.LinearSearch(4);
Assert.IsFalse(isFound);
}
public void TestWithMultipleItemsNotFound()
{
SortableCollection<int> collection = new SortableCollection<int>(new int[] { 4, 11, -3, 7, 9, 23 });
bool isFound = collection.LinearSearch(235);
Assert.IsFalse(isFound);
}
public void InitMethod()
{
collection = new SortableCollection <int>(new List <int>()
{
4, 6, 1, 9, 21, 34, 54, 5, 23
});
}
public static void Main(string[] args)
{
const int NumberOfElementsToSort = 22;
const int MaxValue = 150;
var array = new int[NumberOfElementsToSort];
for (int i = 0; i < NumberOfElementsToSort; i++)
{
array[i] = Random.Next(MaxValue);
}
var collectionToSort = new SortableCollection<int>(array);
// !!!!!!!!!!!!!! collectionToSort.Sort(new BucketSorter { Max = MaxValue });
Console.WriteLine(collectionToSort);
var collection = new SortableCollection<int>(2, -1, 5, 0, -3);
Console.WriteLine(collection);
// collection.Sort(new Quicksorter<int>());
collection.Sort(new InsertionSorter<int>());
Console.WriteLine(collection);
Console.WriteLine(collection.InterpolationSearch(0));
}
public void Test_UpgradedSelectionSorter_ShouldThrowExceptionWhenCollectionIsNull()
{
var sorter = new UpgradedSelectionSorter <int>();
var emptyCollection = new SortableCollection <int>(null);
emptyCollection.Sort(sorter);
}
public void BinarySearchShouldWorkCorrectlyWithEmptyCollection()
{
var collection = new SortableCollection <int>();
var found = collection.BinarySearch(21);
Assert.IsFalse(found, "Element is found in empty collection!");
}
public void SelectionSorterTestWithOneElement()
{
SortableCollection<int> collection = new SortableCollection<int>(new int[] { 5 });
collection.Sort(new SelectionSorter<int>());
Assert.AreEqual(1, collection.Items.Count);
Assert.AreEqual(5, collection.Items[0]);
}
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);
for (int i = 0; i < NumberOfChecks; i++)
{
var item = Random.Next(int.MinValue, collection.Items[0]);
int result = collection.InterpolationSearch(item);
Assert.AreEqual(-1, result);
}
}
public void TestWithMultipleKeys()
{
const int NumberOfElements = 10000;
var elements = new int[NumberOfElements];
for (int i = 0; i < NumberOfElements; i++)
{
elements[i] = Random.Next(-100, 100);
}
Array.Sort(elements);
var collection = new SortableCollection <int>(elements);
foreach (var element in elements)
{
/* this test returns the right result, just a different index than
* what the binary search would return, I don't think that there is an Array.InterpolationSearch
* otherwise, I think that there's nothing wrong with my algorithm*/
int expected = Array.BinarySearch(elements, element);
int result = collection.InterpolationSearch(element);
Assert.AreEqual(expected, result);
}
}
public void TestLinearSearchWithEmptyCollection()
{
var collection = new SortableCollection<int>();
var result = collection.LinearSearch(101);
Assert.IsFalse(result, "Element found in empty collection");
}
private void LoadShippingMethods(Order o)
{
SortableCollection <ShippingRateDisplay> Rates = new SortableCollection <ShippingRateDisplay>();
if (o.HasShippingItems == false)
{
ShippingRateDisplay r = new ShippingRateDisplay();
r.DisplayName = SiteTerms.GetTerm(SiteTermIds.NoShippingRequired);
r.ProviderId = "";
r.ProviderServiceCode = "";
r.Rate = 0;
r.ShippingMethodId = "NOSHIPPING";
Rates.Add(r);
}
else
{
// Shipping Methods
Rates = MTApp.OrderServices.FindAvailableShippingRates(o);
if ((Rates.Count < 1))
{
ShippingRateDisplay result = new ShippingRateDisplay();
result.DisplayName = "Shipping can not be calculated at this time. We will contact you after receiving your order with the exact shipping charges.";
result.ShippingMethodId = "TOBEDETERMINED";
result.Rate = 0;
Rates.Add(result);
}
}
this.litShippingMethods.Text = MerchantTribe.Commerce.Utilities.HtmlRendering.ShippingRatesToRadioButtons(Rates, 300, o.ShippingMethodUniqueKey);
}
internal static void Main(string[] args)
{
var collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
Console.WriteLine("All items before sorting:");
collection.PrintAllItemsOnConsole();
Console.WriteLine("SelectionSorter result:");
collection.Sort(new SelectionSorter<int>());
collection.PrintAllItemsOnConsole();
collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
Console.WriteLine("Quicksorter result:");
collection.Sort(new QuickSorter<int>());
collection.PrintAllItemsOnConsole();
collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
Console.WriteLine("MergeSorter result:");
collection.Sort(new MergeSorter<int>());
collection.PrintAllItemsOnConsole();
Console.WriteLine("Linear search 101:");
Console.WriteLine(collection.LinearSearch(101) + Environment.NewLine);
Console.WriteLine("Binary search 101:");
Console.WriteLine(collection.BinarySearch(101) + Environment.NewLine);
Console.WriteLine("Shuffle:");
collection.Shuffle();
collection.PrintAllItemsOnConsole();
Console.WriteLine("Shuffle again:");
collection.Shuffle();
collection.PrintAllItemsOnConsole();
}
public void Test1SectionSortMethod()
{
var collection = new SortableCollection<int>(new[] { 22, 13 });
collection.Sort(new SelectionSorter<int>());
var testCollection = new SortableCollection<int>(new[] { 13, 22 });
Assert.Equals(collection,testCollection);
}
public void TestWithMultipleMissingKeysLargerThanMaximum()
{
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);
for (int i = 0; i < NumberOfChecks; i++)
{
var item = Random.Next(collection.Items[collection.Count - 1], int.MaxValue);
int result = collection.InterpolationSearch(item);
Assert.AreEqual(-1, result);
}
}
public void Test2SectionSortMethod()
{
var collection1 = new SortableCollection<int>(new[] { 22, 13, 23, 45, -55, 90, 100, 101, -12, 55, 44 });
collection1.Sort(new SelectionSorter<int>());
var testCollection = new SortableCollection<int>(new[] { -55, -12, 13, 22, 23, 44, 45, 55, 90, 100, 101 });
Assert.Equals(testCollection, collection1);
}
public void TestBinarySearchWithExistingElementInLastPositionOddCountOfElements()
{
var collection = new SortableCollection <int>(new[] { 49, 101, 33, 22, 11, 0, 17 });
var result = collection.BinarySearch(17);
Assert.IsTrue(result, "Element not found");
}
public void Test3SectionSortMethod()
{
var collection1 = new SortableCollection<string>(new[] { "aaaa", "cccc", "dddd", "cccc", "caaa", "aacc", "bbdd", "ccff", "eerr", "rrtt", "assdd" });
collection1.Sort(new SelectionSorter<string>());
var testCollection = new SortableCollection<int>(new[] { -55, -12, 13, 22, 23, 44, 45, 55, 90, 100, 101 });
Assert.Equals(testCollection, collection1);
}
public void TestLinearSearch_WithMatchingItemOfDifferentType()
{
var collection = new SortableCollection<double>(new[] { 22d, 11.0d, 101d, 33d, 0d, 101d });
var result = collection.LinearSearch(11u);
Assert.AreEqual(true, result);
}
public void TestBinarySearchWithExistingElementInMiddlePositionEvenCountOfElements()
{
var collection = new SortableCollection<int>(new[] { 49, 101, 33, 22, 11, 0 });
var result = collection.BinarySearch(33);
Assert.IsTrue(result, "Element not found");
}
public void TestShouldnotFindValue()
{
var col = new SortableCollection <int>(new[] { -12, 3, 5 - 3, 1, 5, 6 - 2, -6, -22, 0, 123 });
col.Sort(new MergeSorter <int>());
Assert.IsFalse(col.LinearSearch(99));
}
public SortableCollection <Activity> Search(ActivitySearchParams searchParams,
bool addFlowIsNullQuery, bool includeActivityEntries)
{
SortableCollection <Activity> list = null;
List <object> whereValues;
string sql = ConstructJDBCSearchSql(searchParams, addFlowIsNullQuery, out whereValues);
DoJDBCQueryWithRowCallbackDelegate(sql, whereValues,
delegate(IDataReader reader)
{
if (list == null)
{
list = new SortableCollection <Activity>();
}
Activity activity = MapActivity(reader);
list.Add(activity);
});
if (includeActivityEntries)
{
PostMapActivityEntries(list);
}
return(list);
}
public static void Main()
{
List<int> numbers = new List<int>() { 1,3,5,6,7,3,32,3,5,67,7,4,34,3};
SortableCollection<int> collection = new SortableCollection<int>(numbers);
Console.WriteLine(collection.LinearSearch(7));
}
public void TestLinearSearchWithExistingElementInLastPositionEvenCountOfElements()
{
var collection = new SortableCollection <int>(new[] { 49, 101, 33, 22, 11, 0 });
var result = collection.LinearSearch(0);
Assert.IsTrue(result, "Element not found");
}
public void InsertionSorterTestWithEmptyCollection()
{
SortableCollection <int> collection = new SortableCollection <int>();
collection.Sort(new InsertionSorter <int>());
Assert.AreEqual(0, collection.Items.Count);
}
public void ShouldSortCorrectlyCharacters()
{
var collection = new SortableCollection <char>(new[] { 'a', 'c', 'b' });
collection.Sort(new Quicksorter <char>());
CollectionAssert.AreEqual(new[] { 'a', 'b', 'c' }, collection.Items.ToArray());
}
public void MergeSortShouldWorkCorrectlyWithEmptyCollection()
{
var collection = new SortableCollection<int>();
collection.Sort(new MergeSorter<int>());
Assert.AreEqual(0, collection.Items.Count, "Collection is not empty after sorting!");
}
public void SearchValueFoundInUnsortedCollection()
{
var collection = new SortableCollection <int>(new[] { 14, 1, 3, -4, 10, 5 });
bool actual = collection.LinearSearch(3);
Assert.IsTrue(actual);
}
public void TestLinearSearchWithCollectionOfEqualElements()
{
var collection = new SortableCollection<int>(new[] { 101, 101, 101, 101, 101 });
var result = collection.LinearSearch(101);
Assert.IsTrue(result, "Element not found");
}
public void SearchValueNotFoundInSortedCollection()
{
var collection = new SortableCollection <int>(new[] { -4, 1, 3, 5, 10, 14 });
bool actual = collection.LinearSearch(33);
Assert.IsFalse(actual);
}
public void TestLinearSearchWithExistingElementInFirstPositionEvenCountOfElements()
{
var collection = new SortableCollection<int>(new[] { 49, 101, 33, 22, 11, 0 });
var result = collection.LinearSearch(49);
Assert.IsTrue(result, "Element not found");
}
public void BinarySearchShouldWorkCorrectlyWithEmptyCollection()
{
var collection = new SortableCollection<int>();
var found = collection.BinarySearch(21);
Assert.IsFalse(found, "Element is found in empty collection!");
}
public void TestLinearSearchWithExistingRepeatingElementInCollection()
{
var collection = new SortableCollection<int>(new[] { 101, 101, 33, 22, 11, 0 });
var result = collection.LinearSearch(101);
Assert.IsTrue(result, "Element not found");
}
public void TestBinarySearchWithExistingRepeatingElementInCollection()
{
var collection = new SortableCollection <int>(new[] { 101, 101, 33, 22, 11, 0 });
var result = collection.BinarySearch(101);
Assert.IsTrue(result, "Element not found");
}
public void TestSortWithMultipleElementsMultipleTimes()
{
const int NumberOfAttempts = 10000;
const int MaxNumberOfElements = 1000;
for (int i = 0; i < NumberOfAttempts; i++)
{
var numberOfElements = Random.Next(0, MaxNumberOfElements + 1);
List<int> originalElements = new List<int>(MaxNumberOfElements);
for (int j = 0; j < numberOfElements; j++)
{
originalElements.Add(Random.Next(int.MinValue, int.MaxValue));
}
var collection = new SortableCollection<int>(originalElements);
originalElements.Sort();
collection.Sort(TestSorter);
CollectionAssert.AreEqual(
originalElements,
collection.ToArray(),
"Sort method should sort the elements in ascending order.");
}
}
public void TestBinarySearchWithCollectionOfEqualElements()
{
var collection = new SortableCollection <int>(new[] { 101, 101, 101, 101, 101 });
var result = collection.BinarySearch(101);
Assert.IsTrue(result, "Element not found");
}
public void TestWithRepeatingItemShouldReturnFirstDiscoveredIndex()
{
var collection = new SortableCollection <int>(0, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7);
var result = collection.InterpolationSearch(3);
Assert.AreEqual(4, result);
}
public void TestBinarySearchWithEmptyCollection()
{
var collection = new SortableCollection <int>();
var result = collection.BinarySearch(101);
Assert.IsFalse(result, "Element found in empty collection");
}
public void TestSortWithMultipleElementsMultipleTimes()
{
const int NumberOfAttempts = 10000;
const int MaxNumberOfElements = 1000;
for (int i = 0; i < NumberOfAttempts; i++)
{
var numberOfElements = Random.Next(0, MaxNumberOfElements + 1);
List <int> originalElements = new List <int>(MaxNumberOfElements);
for (int j = 0; j < numberOfElements; j++)
{
originalElements.Add(Random.Next(int.MinValue, int.MaxValue));
}
var collection = new SortableCollection <int>(originalElements);
originalElements.Sort();
collection.Sort(TestSorter);
CollectionAssert.AreEqual(
originalElements,
collection.ToArray(),
"Sort method should sort the elements in ascending order.");
}
}
public static void Main(string[] args)
{
const int NumberOfElementsToSort = 22;
const int MaxValue = 150;
var array = new int[NumberOfElementsToSort];
for (int i = 0; i < NumberOfElementsToSort; i++)
{
array[i] = Random.Next(MaxValue);
}
var collectionToSort = new SortableCollection<int>(array);
collectionToSort.Sort(new BucketSorter { Max = MaxValue });
Console.WriteLine(collectionToSort);
var collectionToShuffle = new SortableCollection<int>(1, 2, 3, 4, 5);
Console.WriteLine("Before shufflin` " + collectionToShuffle);
collectionToShuffle.Shuffle();
Console.WriteLine("After shufflin` " + collectionToShuffle);
var collection = new SortableCollection<int>(2, -1, 5, 0, -3);
Console.WriteLine(collection);
// collection.Sort(new Quicksorter<int>());
collection.Sort(new InsertionSorter<int>());
Console.WriteLine(collection);
}
public void SearchValueFoundInSortedCollection()
{
var collection = new SortableCollection <int>(new[] { -4, 1, 3, 5, 10, 14 });
bool actual = collection.BinarySearch(3);
Assert.IsTrue(actual);
}
static void Main()
{
var collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
Console.WriteLine("All items before sorting:");
Console.WriteLine(collection);
Console.WriteLine("SelectionSorter result:");
collection.Sort(new SelectionSorter<int>());
Console.WriteLine(collection);
Console.WriteLine("Quicksorter result:");
collection.Sort(new Quicksorter<int>());
Console.WriteLine(collection);
Console.WriteLine("MergeSorter result:");
collection.Sort(new MergeSorter<int>());
Console.WriteLine(collection);
Console.WriteLine("Linear search 101:");
Console.WriteLine(collection.LinearSearch(101));
Console.WriteLine("Binary search 101:");
Console.WriteLine(collection.BinarySearch(101));
Console.WriteLine("Shuffle:");
collection.Shuffle();
Console.WriteLine(collection);
Console.WriteLine("Shuffle again:");
collection.Shuffle();
Console.WriteLine(collection);
}
public void BinarySearchNotFoundTest()
{
var collection = new SortableCollection <int>(new[] { 22, 11, 101, 33, 0, 101 });
var actual = collection.BinarySearch(5);
Assert.AreEqual(false, actual);
}
public void BinarySearchFoundPositionAtEndTest()
{
var collection = new SortableCollection <int>(new[] { 22, 11, 101, 33, 0, 101 });
var actual = collection.BinarySearch(22);
Assert.AreEqual(true, actual);
}
public void LinearSearchFoundTest()
{
var collection = new SortableCollection <int>(new[] { 22, 11, 101, 33, 0, 101 });
var actual = collection.LinearSearch(33);
Assert.AreEqual(true, actual);
}
public void BinarySearchNullTest()
{
var collection = new SortableCollection <string>(new[] { "da", "ne" });
string word = null;
collection.BinarySearch(word);
}
private void initViewChart(bool forceRefresh)
{
string cacheKey = "3C26BAC7-1D53-40ef-920B-5BDB705F363B";
CacheWrapper cacheWrapper = Cache[cacheKey] as CacheWrapper;
if (forceRefresh || (cacheWrapper == null))
{
SortableCollection <KeyValuePair <ICatalogable, int> > categoryViews = PageViewDataSource.GetViewsByCategory(_Size, 0, "ViewCount DESC");
if (categoryViews.Count > 0)
{
//BUILD BAR CHART
ViewsChart.Series["Views"].Points.Clear();
for (int i = 0; i < categoryViews.Count; i++)
{
DataPoint point = new DataPoint(ViewsChart.Series["Views"]);
point.SetValueXY(categoryViews[i].Key.Name, new object[] { categoryViews[i].Value });
ViewsChart.Series["Views"].Points.Add(point);
}
ViewsChart.DataBind();
//CACHE THE DATA
cacheWrapper = new CacheWrapper(categoryViews);
Cache.Remove(cacheKey);
Cache.Add(cacheKey, cacheWrapper, null, LocaleHelper.LocalNow.AddMinutes(5).AddSeconds(-1), TimeSpan.Zero, System.Web.Caching.CacheItemPriority.High, null);
}
else
{
//NO CATEGORIES HAVE BEEN VIEWED YET OR PAGE TRACKING IS NOT AVAIALBEL
this.Controls.Clear();
Panel noViewsPanel = new Panel();
noViewsPanel.CssClass = "emptyData";
Label noViewsMessage = new Label();
noViewsMessage.Text = "No categories have been viewed or page tracking is disabled.";
noViewsPanel.Controls.Add(noViewsMessage);
this.Controls.Add(noViewsPanel);
}
}
else
{
//USE CACHED VALUES
SortableCollection <KeyValuePair <ICatalogable, int> > categoryViews = (SortableCollection <KeyValuePair <ICatalogable, int> >)cacheWrapper.CacheValue;
//BUILD BAR CHART
ViewsChart.Series["Views"].Points.Clear();
for (int i = 0; i < categoryViews.Count; i++)
{
DataPoint point = new DataPoint(ViewsChart.Series["Views"]);
point.SetValueXY(categoryViews[i].Key.Name, new object[] { categoryViews[i].Value });
ViewsChart.Series["Views"].Points.Add(point);
}
ViewsChart.DataBind();
ViewsGrid.DataSource = categoryViews;
ViewsGrid.DataBind();
}
DateTime cacheDate = (cacheWrapper != null) ? cacheWrapper.CacheDate : LocaleHelper.LocalNow;
CacheDate1.Text = string.Format(CacheDate1.Text, cacheDate);
CacheDate2.Text = string.Format(CacheDate2.Text, cacheDate);
}
public void TestSortingOnSixPositiveNumbers()
{
var collection = new SortableCollection <int>(new[] { 22, 11, 101, 33, 5, 101 });
collection.Sort(new SelectionSorter <int>());
Assert.AreEqual(true, this.AreElementsEqual(collection));
}
public void TestSortingOnSixNegativeNumbers()
{
var collection = new SortableCollection <int>(new[] { -22, -11, -101, -33, -5, -101 });
collection.Sort(new SelectionSorter <int>());
Assert.AreEqual(true, this.AreElementsEqual(collection));
}
public void TestLinearSearch_ItemNotFound()
{
int[] numbers = new int[] { 1, 76, -205, 17, 90, 22 };
SortableCollection<int> collection = new SortableCollection<int>(numbers);
bool numberFound = collection.LinearSearch(8);
Assert.AreEqual(false, numberFound);
}
public void TestBinarySearch_ItemEqualToMaximum()
{
int[] sortedNumbers = new int[] { 1, 5, 7, 9, 22 };
SortableCollection<int> collection = new SortableCollection<int>(sortedNumbers);
bool numberFound = collection.BinarySearch(22);
Assert.AreEqual(true, numberFound);
}
public void TestBinarySearch_ItemGreaterThanMaximum()
{
int[] sortedNumbers = new int[] { 1, 5, 7, 9, 22 };
SortableCollection<int> collection = new SortableCollection<int>(sortedNumbers);
bool numberFound = collection.BinarySearch(30);
Assert.AreEqual(false, numberFound);
}
public void TestLinearSearch_ItemFound()
{
int[] numbers = new int[] { 11, 54, -7, 19, -22 };
SortableCollection<int> collection = new SortableCollection<int>(numbers);
bool numberFound = collection.LinearSearch(-7);
Assert.AreEqual(true, numberFound);
}
