public void CopyIfTest()
{
int[] data = { 1, 2, 3 };
int expectedCount = 1;
int actualCount = 0;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.CopyIf(inputIterator, outputIterator, delegate(int x)
{
return(x > 2);
});
actualCount = lst.Count();
}
}
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 3);
Assert.IsTrue(isCorrectData);
}
public void ReplaceCopyIfTest()
{
int[] data = { 1, 2, 3 };
IList <int> lst = new List <int>();
using (InputIterator <int> inputIterator = new InputIterator <int>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.ReplaceCopyIf(inputIterator, outputIterator, delegate(int x)
{
return(x == 3);
}, 2);
//checking if the input data is not changed
bool isCorrectInputData = (inputIterator[0] == 1 &&
inputIterator[1] == 2 &&
inputIterator[2] == 3);
Assert.IsTrue(isCorrectInputData);
//checking if the output data is changed
bool isCorrectOutputData = (lst[0] == 1 && lst[1] == 2 &&
lst[2] == 2);
Assert.IsTrue(isCorrectOutputData);
}
}
}
public void RemoveCopyTest()
{
int[] data = { 1, 2, 2, 3 };
int expectedCount = 3;
int actualCount = 0;
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
IList <int> lst = new List <int>();
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.RemoveCopy(inputIterator, outputIterator, 3);
actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 1 && lst[1] == 2 && lst[2] == 2);
Assert.IsTrue(isCorrectData);
}
}
}
public void SortTest()
{
int[] data = { 6, 1, 3, 5, 7, 2, 4 };
IList<int> lst = new List<int>();
int expectedCount = 7;
using (IForwardIterator<int> inputIterator=new ForwardIterator<int>(data))
{
Algorithm.Sort(inputIterator);
using (IOutputIterator<int> outputIterator = new BackInsertIterator<int>(lst))
{
inputIterator.Begin();
Algorithm.Copy(inputIterator, outputIterator);
}
int actualCount = lst.Count();
Assert.IsTrue(expectedCount==actualCount);
}
bool isCorrectData = (lst[0] == 1 && lst[1] == 2 &&
lst[2] == 3 && lst[3] == 4 &&
lst[4] == 5 && lst[5]==6 &&
lst[6] == 7);
Assert.IsTrue(isCorrectData);
}
public void MoveBackwardTest()
{
int[] data = { 1, 2, 3 };
IList <int> lst = new List <int>();
int expectedCount = 3;
int actualCount = 0;
using (BidirectionalIterator <int> inputIterator = new BidirectionalIterator <int>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.MoveBackward(inputIterator, outputIterator);
actualCount = lst.Count();
}
//whether the data is actually remove
Assert.IsTrue(inputIterator.Count() == 0);
}
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 3 && lst[1] == 2 && lst[2] == 1);
Assert.IsTrue(isCorrectData);
}
public void SetDifferenceTest()
{
int[] data1 = { 1, 2, 5, 5, 5, 9 };
int[] data2 = { 2, 5, 7 };
int expectedCount = 4;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator1 = new InputIterator <int>(data1))
{
using (IInputIterator <int> inputIterator2 = new InputIterator <int>(data2))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.SetDifference(inputIterator1, inputIterator2, outputIterator);
}
}
}
int actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 1 && lst[1] == 5 &&
lst[2] == 5 && lst[3] == 9);
Assert.IsTrue(isCorrectData);
}
public void EqualRangeTest()
{
int[] data = { 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6 };
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
KeyValuePair <int, int> result = Algorithm.EqualRange(inputIterator, 4);
int lowerBound = result.Key;
int upperBound = result.Value;
int count = upperBound - lowerBound;
using (IInputIterator <int> inputIterator2 = new RangeInputIterator <int>(data, lowerBound, count))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.Copy(inputIterator2, outputIterator);
}
}
}
Assert.IsTrue(lst.Count() == 3);
Assert.IsTrue(lst[0] == 4 &&
lst[1] == 4 &&
lst[2] == 4);
}
public void SetSymmetricDifference()
{
int[] data1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
int[] data2 = { 5, 7, 9, 10 };
int expectedCount = 8;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator1 = new InputIterator <int>(data1))
{
using (IInputIterator <int> inputIterator2 = new InputIterator <int>(data2))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.SetSymmetricDifference(inputIterator1, inputIterator2, outputIterator);
}
}
}
int actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 1 && lst[1] == 2 &&
lst[2] == 3 && lst[3] == 4 &&
lst[4] == 6 && lst[5] == 8 &&
lst[6] == 9 && lst[7] == 10);
Assert.IsTrue(isCorrectData);
}
public void SetUnionTest2()
{
int[] data = { 1, 2, 3, 4, 5, 5, 5 };
int[] data2 = { 3, 4, 5, 6, 7 };
int expectedCount = 9;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator1 = new InputIterator <int>(data))
{
using (IInputIterator <int> inputIterator2 = new InputIterator <int>(data2))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.SetUnion(inputIterator1, inputIterator2, outputIterator);
}
}
}
int actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 1 && lst[1] == 2 &&
lst[2] == 3 && lst[3] == 4 &&
lst[4] == 5 && lst[5] == 5 &&
lst[6] == 5 && lst[7] == 6 &&
lst[8] == 7);
Assert.IsTrue(isCorrectData);
}
public void TransformTest()
{
int[] data = { 1, 2, 3 };
IList <int> lst = new List <int>();
int expectedCount = 3;
int expectedSum = 9;
int actualCount = 0;
int actualSum = 0;
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.Transform(inputIterator, outputIterator, delegate(int x)
{
return(x + 1);
});
actualCount = lst.Count();
actualSum = lst.Sum();
}
}
Assert.IsTrue(expectedCount == actualCount);
Assert.IsTrue(expectedSum == actualSum);
}
public void OutputIteratorAdapterTest()
{
string[] data = { "1", "2", "3", "4" };
IList <int> lst = new List <int>();
using (IInputIterator <string> inputIterator = new InputIterator <string>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
using (IOutputIterator <string> adapter = new OutputIteratorAdapter <int, string>(outputIterator,
new StringToIntConverter()))
{
while (!inputIterator.IsEnd())
{
adapter.Write(inputIterator.Read());
inputIterator.MoveNext();
}
}
}
}
bool isCorrectData = (lst[0] == 1 && lst[1] == 2 &&
lst[2] == 3 && lst[3] == 4);
Assert.IsTrue(isCorrectData);
}
public void CopyNTest()
{
int[] data = { 1, 2, 3, 4, 5, 6 };
int expectedCount = 2;
int actualCount = 0;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.CopyN(inputIterator, 2, outputIterator);
actualCount = lst.Count();
}
}
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 1 && lst[1] == 2);
Assert.IsTrue(isCorrectData);
}
public void RotateCopyTest2()
{
int[] data = { 1, 2, 3, 4, 5 };
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
IShallowClone cloneable = (IShallowClone)inputIterator;
IInputIterator <int> cloneObj = cloneable.ShallowClone() as IInputIterator <int>;
cloneObj.End();
ICursor cursor = (ICursor)cloneObj;
cursor.SetPosition(cursor.GetPosition() - 2);
//set the first element to 4element position
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.RotateCopy(inputIterator, cloneObj, outputIterator);
}
}
bool isCorrectData = (lst[0] == 4 && lst[1] == 5 &&
lst[2] == 1 && lst[3] == 2 &&
lst[4] == 3);
Assert.IsTrue(isCorrectData);
}
public void SetIntersectionTest()
{
int[] data1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
int[] data2 = { 5, 7, 9, 10 };
int expectedCount = 2;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator1 = new InputIterator <int>(data1))
{
using (IInputIterator <int> inputIterator2 = new InputIterator <int>(data2))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.SetIntersection(inputIterator1, inputIterator2, outputIterator);
}
}
}
int actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
Assert.IsTrue(lst[0] == 5 && lst[1] == 7);
}
public void MergeTest()
{
int[] data = { 0, 1, 3, 4, 4 };
int[] data2 = { 0, 2, 2, 3, 6 };
int expectedCount = 10;
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator1 = new InputIterator <int>(data))
{
using (IInputIterator <int> inputIterator2 = new InputIterator <int>(data2))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.Merge(inputIterator1, inputIterator2, outputIterator);
}
}
}
int actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == 0 && lst[1] == 0 &&
lst[2] == 1 && lst[3] == 2 &&
lst[4] == 2 && lst[5] == 3 &&
lst[6] == 3 && lst[7] == 4 &&
lst[8] == 4 && lst[9] == 6);
Assert.IsTrue(isCorrectData);
}
public void ReverseCopyTest()
{
int[] data = { 1, 2, 3 };
IList <int> lst = new List <int>();
using (IBidirectionalIterator <int> inputIterator = new BidirectionalIterator <int>(data))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.ReverseCopy(inputIterator, outputIterator);
}
Assert.IsTrue(lst[0] == 3 && lst[1] == 2 && lst[2] == 1);
}
}
public void PartitionCopyTest()
{
int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
IList <int> trueList = new List <int>();
IList <int> falseList = new List <int>();
UnaryPredicate <int> isEven = delegate(int x)
{
return(x % 2 == 0);
};
using (ForwardIterator <int> inputIterator = new ForwardIterator <int>(data))
{
using (IOutputIterator <int> trueOutputIterator = new BackInsertIterator <int>(trueList))
{
using (IOutputIterator <int> falseOutputIterator = new BackInsertIterator <int>(falseList))
{
Algorithm.PartitionCopy(inputIterator, trueOutputIterator,
falseOutputIterator, isEven);
bool isEvenCorrect = (trueList[0] == 0 &&
trueList[1] == 2 &&
trueList[2] == 4 &&
trueList[3] == 6 &&
trueList[4] == 8);
bool isOddCorrect = (falseList[0] == 1 &&
falseList[1] == 3 &&
falseList[2] == 5 &&
falseList[3] == 7 &&
falseList[4] == 9);
Assert.IsTrue(isEvenCorrect && isOddCorrect);
}
}
}
}
public void UniqueCopyTest()
{
string[] data = new string[]
{
"hello",
"world",
"road",
"road",
"cool",
"job",
"road"
};
int expectedCount = 6;
int actualCount = 0;
IList <string> lst = new List <string>();
using (ForwardIterator <string> inputIterator = new ForwardIterator <string>(data))
{
using (IOutputIterator <string> outputIterator = new BackInsertIterator <string>(lst))
{
Algorithm.UniqueCopy(inputIterator, outputIterator);
actualCount = lst.Count();
Assert.IsTrue(expectedCount == actualCount);
bool isCorrectData = (lst[0] == "hello" &&
lst[1] == "world" &&
lst[2] == "world" &&
lst[3] == "cool" &&
lst[4] == "job" &&
lst[5] == "road");
}
}
}
public void MultiOutputIteratorTest()
{
int[] data = { 1, 2, 3 };
IList <int> lst1 = new List <int>();
IList <int> lst2 = new List <int>();
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
using (IOutputIterator <int> outputIterator1 = new BackInsertIterator <int>(lst1))
{
using (IOutputIterator <int> outputIterator2 = new BackInsertIterator <int>(lst2))
{
using (MultiOutputIterator <int> adapter = new MultiOutputIterator <int>())
{
adapter.Add(outputIterator1);
adapter.Add(outputIterator2);
while (!inputIterator.IsEnd())
{
adapter.Write(inputIterator.Read());
adapter.MoveNext();
inputIterator.MoveNext();
}
}
}
}
}
bool isCorrectData = (lst1[0] == 1 && lst1[1] == 2 && lst1[2] == 3 &&
lst2[0] == 1 && lst2[1] == 2 && lst2[2] == 3);
Assert.IsTrue(isCorrectData);
}
public void BoundTest()
{
int[] data = { 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6 };
IList <int> lst = new List <int>();
using (IInputIterator <int> inputIterator = new InputIterator <int>(data))
{
ICursor cursor = inputIterator as ICursor;
Algorithm.LowerBound(inputIterator, 4);
int lowerBoundIndex = cursor.GetPosition();
inputIterator.Begin();
Algorithm.UpperBound(inputIterator, 4);
int upperBoundIndex = cursor.GetPosition();
int count = upperBoundIndex - lowerBoundIndex;
using (IInputIterator <int> inputIterator2 = new RangeInputIterator <int>(data, lowerBoundIndex, count))
{
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.Copy(inputIterator2, outputIterator);
}
}
}
Assert.IsTrue(lst.Count() == 3);
Assert.IsTrue(lst[0] == 4 &&
lst[1] == 4 &&
lst[2] == 4);
}
public void RotateTest2()
{
int[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
IList <int> lst = new List <int>();
using (IForwardIterator <int> inputIterator = new ForwardIterator <int>(data))
{
IShallowClone cloneable = (IShallowClone)inputIterator;
IForwardIterator <int> cloneObj = cloneable.ShallowClone() as IForwardIterator <int>;
cloneObj.End();
ICursor cursor = (ICursor)cloneObj;
cursor.SetPosition(cursor.GetPosition() - 2);
//set the first element to 8 element position
Algorithm.Rotate(inputIterator, cloneObj);
inputIterator.Begin();
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst))
{
Algorithm.Copy(inputIterator, outputIterator);
}
}
bool isCorrectData = (lst[0] == 8 && lst[1] == 9 &&
lst[2] == 1 && lst[3] == 2 &&
lst[4] == 3 && lst[5] == 4 &&
lst[6] == 5 && lst[7] == 6 &&
lst[8] == 7);
Assert.IsTrue(isCorrectData);
}
public void Shuffle()
{
int[] data = { 1, 2, 3, 4, 5, 6, 7, 8 };
int seed = 23;
IList <int> lst1 = new List <int>();
IList <int> lst2 = new List <int>();
using (IForwardIterator <int> inputIterator = new ForwardIterator <int>(data))
{
Algorithm.Shuffle(inputIterator, seed);
inputIterator.Begin();
bool isSorted = Algorithm.IsSorted(inputIterator);
//we have random the data , therefore it should not be sorted
//the chance of returning the sorted data is very small
Assert.IsFalse(isSorted);
inputIterator.Begin();
//copy the random data to list 1
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst1))
{
Algorithm.Copy(inputIterator, outputIterator);
}
inputIterator.Begin();
//copy the random data to list 2
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst2))
{
Algorithm.Copy(inputIterator, outputIterator);
}
}
using (IForwardIterator <int> inputIterator = new ForwardIterator <int>(data))
{
//shuffle another time
Algorithm.Shuffle(inputIterator, seed);
//copy the random data to list 2
using (IOutputIterator <int> outputIterator = new BackInsertIterator <int>(lst1))
{
Algorithm.Copy(inputIterator, outputIterator);
}
}
bool isCorrectData = (lst1[0] == lst2[0] && lst1[1] == lst2[1] &&
lst1[2] == lst2[2] &&
lst1[3] == lst2[3] &&
lst1[4] == lst2[4] &&
lst1[5] == lst2[5] &&
lst1[6] == lst2[6] &&
lst1[7] == lst2[7]);
//since we use the same seed,both shuffle data should be same
Assert.IsTrue(isCorrectData);
}