[Test] public void Mismatch_RandomIterator()
{
array1[7]++;
ListIterator <int> cmpIter = IteratorUtil.Begin(array2);
cmpIter.MoveNext();
cmpIter.MoveNext();
RandomAccessIterator <int> beginR = IteratorUtil.Begin(array1);
RandomAccessIterator <int> endR = IteratorUtil.End(array1);
RandomAccessIterator <int> cmpR = cmpIter;
Pair <RandomAccessIterator <int>, RandomAccessIterator <int> > pR = Algorithm.Mismatch(beginR, endR, cmpR);
Assert.AreEqual(7, pR.First.Position);
Assert.AreEqual(array1[7], pR.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.First);
Assert.AreEqual(9, pR.Second.Position);
Assert.AreEqual(array2[9], pR.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.Second);
pR = Algorithm.Mismatch(beginR, endR, cmpR, EqualityComparer <int> .Default);
Assert.AreEqual(7, pR.First.Position);
Assert.AreEqual(array1[7], pR.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.First);
Assert.AreEqual(9, pR.Second.Position);
Assert.AreEqual(array2[9], pR.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pR.Second);
}
public void MoveNextFromEndOfCollectionBoolResult()
{
//Arrange
ListIterator <int> listIterator = new ListIterator <int>(new List <int>()
{
1, 2, 3
});
//Act
listIterator.MoveNext();
listIterator.MoveNext();
bool result = listIterator.MoveNext();
//Assert
Assert.IsFalse(result);
}
public void ResetTest()
{
//Arrange & Act
ListIterator <int> listIterator = new ListIterator <int>(new List <int>()
{
1, 2, 3
});
//Act
listIterator.MoveNext();
listIterator.MoveNext();
listIterator.Reset();
//Assert
Assert.AreEqual(0, listIterator.CurrentIndex);
}
[Test] public void Mismatch_ListIterator()
{
array1[7]++;
ListIterator <int> cmpIter = IteratorUtil.Begin(array2);
cmpIter.MoveNext();
cmpIter.MoveNext();
Pair <ListIterator <int>, ListIterator <int> > p = Algorithm.Mismatch(IteratorUtil.Begin(array1), IteratorUtil.End(array1), cmpIter);
Assert.AreEqual(7, p.First.Position);
Assert.AreEqual(array1[7], p.First.Read());
Assert.AreEqual(9, p.Second.Position);
Assert.AreEqual(array2[9], p.Second.Read());
p = Algorithm.Mismatch(IteratorUtil.Begin(array1), IteratorUtil.End(array1), cmpIter, EqualityComparer <int> .Default);
Assert.AreEqual(7, p.First.Position);
Assert.AreEqual(array1[7], p.First.Read());
Assert.AreEqual(9, p.Second.Position);
Assert.AreEqual(array2[9], p.Second.Read());
}
[Test] public void UniqueCopy_List_Comparer_OutputIterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <int> result = Algorithm.UniqueCopy(src, destIter, EqualityComparer <int> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, (result as ListIterator <int>).Position);
Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read());
}
[Test] public void UniqueCopy_ListIterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <int> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(Int32.MinValue, result.Read());
}
[Test] public void UniqueCopy_List_Predicate_ListIterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <int> result = Algorithm.UniqueCopy(src, destIter, delegate(int lhs, int rhs) { return(lhs == rhs); });
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read());
}
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
var iterator = new ListIterator(this);
while (iterator.MoveNext())
{
object obj = iterator.Current;
stringBuilder.AppendFormat("{0} ", obj);
}
stringBuilder.Remove(stringBuilder.Length - 1, 1);
return(stringBuilder.ToString());
}
[Test] public void RemoveCopyIf_List_ListIterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <int> result = Algorithm.RemoveCopyIf(src, destIter, Is29);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(src.Length - 3, result.Position);
Assert.AreEqual(Int32.MinValue, result.Read());
}
[Test] public void RemoveCopy_Comparer_ListIterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <int> result = Algorithm.RemoveCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, 29, EqualityComparer <int> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(src.Length - 3, result.Position);
Assert.AreEqual(Int32.MinValue, result.Read());
}
[Test] public void Transform_Binary()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Transform(IteratorUtil.Begin(src), IteratorUtil.End(src), IteratorUtil.Begin(src), destIter, AddEm);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
Assert.AreEqual(src[i] * 2, dest[i + 1]);
}
}
[Test] public void UniqueCopy_Comparer_ListIterator()
{
ListIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <string> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, EqualityComparer <string> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(MARKER, (result as ListIterator <string>).Read());
}
[Test] public void UniqueCopy_List_Predicate_ListIterator()
{
ListIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
ListIterator <string> result = Algorithm.UniqueCopy(src, destIter, delegate(string lhs, string rhs) { return(lhs == rhs); });
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Position);
Assert.AreEqual(MARKER, (result as ListIterator <string>).Read());
}
public void MoveNextCurrentIndex()
{
//Arrange
ListIterator <int> listIterator = new ListIterator <int>(new List <int>()
{
1, 2, 3
});
//Act
bool result = listIterator.MoveNext();
//Assert
Assert.AreEqual(1, listIterator.CurrentIndex);
}
[Test] public void Reverse_Enumerable2Iterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.ReverseCopy(GetEnumerable(), destIter);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
Assert.AreEqual(src[i], dest[dest.Length - 2 - i]);
}
}
public void MoveNextBoolResult()
{
//Arrange
ListIterator <int> listIterator = new ListIterator <int>(new List <int>()
{
1, 2, 3
});
//Act
bool result = listIterator.MoveNext();
//Assert
Assert.IsTrue(result);
}
[Test] public void Mismatch_ForwardIterator()
{
array1[7]++;
ListIterator <int> cmpIter = IteratorUtil.Begin(array2);
cmpIter.MoveNext();
cmpIter.MoveNext();
ForwardIterator <int> beginF = IteratorUtil.Begin(array1);
ForwardIterator <int> endF = IteratorUtil.End(array1);
ForwardIterator <int> cmpF = cmpIter;
Pair <ForwardIterator <int>, ForwardIterator <int> > pF = Algorithm.Mismatch(beginF, endF, cmpF);
Assert.AreEqual(array1[7], pF.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pF.First);
Assert.AreEqual(array2[9], pF.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pF.Second);
pF = Algorithm.Mismatch(beginF, endF, cmpF, EqualityComparer <int> .Default);
Assert.AreEqual(array1[7], pF.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pF.First);
Assert.AreEqual(array2[9], pF.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), pF.Second);
}
[Test] public void Copy_Enumerable()
{
ListIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(src, destIter);
Assert.AreEqual(dest[0], MARKER);
Assert.AreEqual(dest[dest.Length - 1], MARKER);
for (int i = 0; i < src.Length; ++i)
{
Assert.AreEqual(dest[i + 1], src[i]);
}
}
[Test] public void Mismatch_InputIterator()
{
array1[7]++;
ListIterator <int> cmpIter = IteratorUtil.Begin(array2);
cmpIter.MoveNext();
cmpIter.MoveNext();
InputIterator <int> begin = IteratorUtil.Begin(array1);
InputIterator <int> end = IteratorUtil.End(array1);
InputIterator <int> cmp = cmpIter;
Pair <InputIterator <int>, InputIterator <int> > p = Algorithm.Mismatch(begin, end, cmp);
Assert.AreEqual(array1[7], p.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), p.First);
Assert.AreEqual(array2[9], p.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), p.Second);
p = Algorithm.Mismatch(begin, end, cmp, EqualityComparer <int> .Default);
Assert.AreEqual(array1[7], p.First.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), p.First);
Assert.AreEqual(array2[9], p.Second.Read());
Assert.IsInstanceOfType(typeof(ListIterator <int>), p.Second);
}
public void HasNextTestFromSecondLastElement()
{
//Arrange
ListIterator <int> listIterator = new ListIterator <int>(new List <int>()
{
1, 2, 3
});
//Act
listIterator.MoveNext();
bool result = listIterator.HasNext();
//Assert
Assert.IsTrue(result);
}
[Test] public void Copy_Enumerable()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(src, destIter);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
Assert.AreEqual(dest[i + 1], src[i]);
}
}
[Test] public void Generate_Iterator()
{
int[] array = new int[10];
ListIterator <int> begin = IteratorUtil.Begin(array);
ListIterator <int> end = IteratorUtil.End(array);
begin.MoveNext();
end.MovePrev();
Algorithm.Generate(begin, end, Generator);
Assert.AreEqual(0, array[0]);
Assert.AreEqual(0, array[array.Length - 1]);
for (int i = 1; i < array.Length - 1; ++i)
{
Assert.AreEqual(42, array[i]);
}
}
[Test] public void Reverse_Iterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(src, destIter);
ListIterator <int> endIter = IteratorUtil.End(dest);
endIter.MovePrev();
Algorithm.Reverse(destIter, endIter);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
Assert.AreEqual(src[i], dest[dest.Length - 2 - i]);
}
}
[Test] public void FillN_Iterator()
{
int[] array = new int[10];
ListIterator <int> begin = IteratorUtil.Begin(array);
ListIterator <int> end = IteratorUtil.End(array);
begin.MoveNext();
end.MovePrev();
OutputIterator <int> result = Algorithm.FillN(begin, 8, 42);
Assert.AreEqual(0, array[0]);
Assert.AreEqual(0, array[array.Length - 1]);
for (int i = 1; i < array.Length - 1; ++i)
{
Assert.AreEqual(42, array[i]);
}
Assert.IsNotNull(result);
Assert.IsInstanceOfType(typeof(ListIterator <int>), result);
Assert.AreEqual(9, (result as ListIterator <int>).Position);
}
[Test] public void Copy_EnumerableInt()
{
// test using simple int arrays
int[] src = Constants.TEST_INT_ARRAY;
int[] dest = new int[src.Length + 2];
dest[0] = Int32.MinValue;
dest[dest.Length - 1] = Int32.MinValue;
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(src, destIter);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < src.Length; ++i)
{
Assert.AreEqual(dest[i + 1], src[i]);
}
}
[Test] public void Copy_EnumerableString()
{
// test using simple int arrays
string[] src = Constants.TEST_STRING_ARRAY;
string[] dest = new string[src.Length + 2];
dest[0] = "XXXX";
dest[dest.Length - 1] = "XXXX";
ListIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(src, destIter);
Assert.AreEqual(dest[0], "XXXX");
Assert.AreEqual(dest[dest.Length - 1], "XXXX");
for (int i = 0; i < src.Length; ++i)
{
Assert.AreEqual(dest[i + 1], src[i]);
}
}
[Test] public void ReplaceCopy_Comparer()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.ReplaceCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, 29, 42, EqualityComparer <int> .Default);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
if (src[i] == 29)
{
Assert.AreEqual(42, dest[i + 1]);
}
else
{
Assert.AreEqual(src[i], dest[i + 1]);
}
}
}
[Test] public void SwapRanges_Iterator()
{
int[] src2 = new int[src.Length];
for (int i = 0; i < count; ++i)
{
src2[i] = -src[i];
}
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter); // we assume Algorithm.Copy is good. It has its own unit test.
Algorithm.SwapRanges(IteratorUtil.Begin(src2), IteratorUtil.End(src2), destIter);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
Assert.AreEqual(-src[i], dest[i + 1]);
Assert.AreEqual(src[i], src2[i]);
}
}
[Test] public void ReplaceIf_Iterator()
{
ListIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
Algorithm.Copy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter); // we assume Algorithm.Copy is good. It has its own unit test.
Algorithm.ReplaceIf(IteratorUtil.Begin(dest), IteratorUtil.End(dest), 42, Is29);
Assert.AreEqual(dest[0], Int32.MinValue);
Assert.AreEqual(dest[dest.Length - 1], Int32.MinValue);
for (int i = 0; i < count; ++i)
{
if (src[i] == 29)
{
Assert.AreEqual(42, dest[i + 1]);
}
else
{
Assert.AreEqual(src[i], dest[i + 1]);
}
}
}
