[Test] public void RemoveIf_ForwardIterator() { ForwardIterator <int> begin = IteratorUtil.Begin(src); ForwardIterator <int> end = IteratorUtil.End(src); ForwardIterator <int> result = Algorithm.RemoveIf(begin, end, Is29); Assert.IsNotNull(result); Assert.AreEqual(0, (begin as ListIterator <int>).Position); Assert.AreEqual(src.Length, IteratorUtil.Distance(begin, end)); Assert.AreEqual(src.Length - 4, IteratorUtil.Distance(begin, result)); }
[Test] public void UniqueCopy_Comparer_ForwardIterator() { ForwardIterator <string> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <string> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, EqualityComparer <string> .Default); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(6, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(MARKER, result.Read()); }
[Test] public void UniqueCopy_Predicate_ForwardIterator() { ForwardIterator <string> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <string> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, delegate(string lhs, string rhs) { return(lhs == rhs); }); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(6, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(MARKER, result.Read()); }
[Test] public void UniqueCopy_ForwardIterator() { ForwardIterator <int> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <int> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(6, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(Int32.MinValue, result.Read()); }
[Test] public void UniqueCopy_List_Comparer_ForwardIterator() { ForwardIterator <int> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <int> result = Algorithm.UniqueCopy(src, destIter, EqualityComparer <int> .Default); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(6, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read()); }
[Test] public void RemoveCopy_List_ForwardIterator_Comparer() { ForwardIterator <int> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <int> result = Algorithm.RemoveCopy(src, destIter, 29, EqualityComparer <int> .Default); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(src.Length - 3, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(Int32.MinValue, result.Read()); }
[Test] public void RemoveCopyIf_ForwardIterator() { ForwardIterator <int> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <int> result = Algorithm.RemoveCopyIf(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, Is29); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(src.Length - 3, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(Int32.MinValue, result.Read()); }
public void SwapRangeTest() { using (ForwardIterator <int> inputIterator1 = new ForwardIterator <int>(new int[] { 1, 2 })) { using (ForwardIterator <int> inputIterator2 = new ForwardIterator <int>(new int[] { 3, 4 })) { Algorithm.SwapRange(inputIterator1, inputIterator2); Assert.IsTrue(inputIterator1[0] == 3 && inputIterator1[1] == 4 && inputIterator2[0] == 1 && inputIterator2[1] == 2); } } }
public static ForwardIterator <T> Remove <T>(ForwardIterator <T> begin, ForwardIterator <T> end, T value) where T : IEquatable <T> { ForwardIterator <T> iter = Find(begin, end, value); if (iter == null) { return(null); } //ForwardIterator<T> dest = IteratorUtil.Clone(iter); return(RemoveCopy(iter, end, iter, value)); }
[Test] public void UniqueCopy_List_Predicate_ForwardIterator() { ForwardIterator <int> destIter = IteratorUtil.Begin(dest); destIter.MoveNext(); ForwardIterator <int> result = Algorithm.UniqueCopy(src, destIter, delegate(int lhs, int rhs) { return(lhs == rhs); }); VerifyOutput(); Assert.IsNotNull(result); Assert.AreEqual(6, IteratorUtil.Distance(IteratorUtil.Begin(dest), result)); Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read()); }
public static ForwardIterator <T> SearchN <T>(ForwardIterator <T> begin, ForwardIterator <T> end, int count, Functional.UnaryPredicate <T> func) { if (begin.Equals(end) || (count <= 0)) { return(null); } if (count == 1) { return(FindIf(begin, end, func)); } begin = IteratorUtil.Clone(begin); while (!begin.Equals(end)) { begin = FindIf(begin, end, func); if (begin == null) { return(null); } ForwardIterator <T> iter = IteratorUtil.Clone(begin); iter.MoveNext(); if (iter.Equals(end)) { return(null); } int matchCount = count - 1; while (func(iter.Read())) { --matchCount; if (matchCount == 0) { return(begin); } iter.MoveNext(); if (iter.Equals(end)) { return(null); } } begin.MoveNext(); } return(null); }
public static ForwardIterator <T> SearchN <T>(ForwardIterator <T> begin, ForwardIterator <T> end, int count, T value, IEqualityComparer <T> comparer) { if (begin.Equals(end) || (count <= 0)) { return(null); } if (count == 1) { return(Find(begin, end, value, comparer)); } begin = IteratorUtil.Clone(begin); while (!begin.Equals(end)) { begin = Find(begin, end, value, comparer); if (begin == null) { return(null); } ForwardIterator <T> iter = IteratorUtil.Clone(begin); iter.MoveNext(); if (iter.Equals(end)) { return(null); } int matchCount = count - 1; while (comparer.Equals(iter.Read(), value)) { --matchCount; if (matchCount == 0) { return(begin); } iter.MoveNext(); if (iter.Equals(end)) { return(null); } } begin.MoveNext(); } return(null); }
[Test] public void Search_Iterator() { int[] array = Constants.TEST_INT_ARRAY; int[] search = new int[3]; Algorithm.CopyN(array, 5, 3, search, 0); ForwardIterator <int> result = Algorithm.Search(IteratorUtil.Begin(array), IteratorUtil.End(array), IteratorUtil.Begin(search), IteratorUtil.End(search)); Assert.IsNotNull(result); Assert.IsInstanceOfType(typeof(ListIterator <int>), result); Assert.AreEqual(5, IteratorUtil.Distance(IteratorUtil.Begin(array), result)); Assert.AreEqual(array[5], result.Read()); }
public void ReplaceTest() { int[] data = { 1, 2, 3 }; using (ForwardIterator <int> inputIterator = new ForwardIterator <int>(data)) { Algorithm.Replace(inputIterator, 3, 2); bool isCorrectData = (inputIterator[0] == 1 && inputIterator[1] == 2 && inputIterator[2] == 2); Assert.IsTrue(isCorrectData); } }
public void FillTest() { using (ForwardIterator <int> inputIterator = new ForwardIterator <int>(3)) { Algorithm.Fill(inputIterator, 5); Assert.IsTrue(inputIterator.Count() == 3); bool isCorrectData = (inputIterator[0] == 5 && inputIterator[1] == 5 && inputIterator[2] == 5); Assert.IsTrue(isCorrectData); } }
public static ForwardIterator <T> Unique <T>(ForwardIterator <T> begin, ForwardIterator <T> end, Functional.BinaryPredicate <T> op) { if (begin.Equals(end)) { return(null); } ForwardIterator <T> firstMatch = AdjacentFind(begin, end, op) as ForwardIterator <T>; if (firstMatch != null) { return(UniqueCopy(firstMatch, end, firstMatch, op) as ForwardIterator <T>); } return(null); }
public static ForwardIterator <T> Unique <T>(ForwardIterator <T> begin, ForwardIterator <T> end, IEqualityComparer <T> comp) { if (begin.Equals(end)) { return(null); } ForwardIterator <T> firstMatch = AdjacentFind(begin, end, comp) as ForwardIterator <T>; if (firstMatch != null) { return(UniqueCopy(firstMatch, end, firstMatch, comp) as ForwardIterator <T>); } return(null); }
public static ForwardIterator <T> FindFirstOf <T>(ForwardIterator <T> begin, ForwardIterator <T> end, ForwardIterator <T> searchBegin, ForwardIterator <T> searchEnd, Functional.BinaryPredicate <T> func) { begin = IteratorUtil.Clone(begin); for (; !begin.Equals(end); begin.MoveNext()) { for (ForwardIterator <T> searchIter = IteratorUtil.Clone(searchBegin); !searchIter.Equals(searchEnd); searchIter.MoveNext()) { if (func(begin.Read(), searchIter.Read())) { return(begin); } } } return(null); }
public static ForwardIterator <T> FindFirstOf <T>(ForwardIterator <T> begin, ForwardIterator <T> end, ForwardIterator <T> searchBegin, ForwardIterator <T> searchEnd, IEqualityComparer <T> comparer) { begin = IteratorUtil.Clone(begin); for (; !begin.Equals(end); begin.MoveNext()) { for (ForwardIterator <T> searchIter = IteratorUtil.Clone(searchBegin); !searchIter.Equals(searchEnd); searchIter.MoveNext()) { if (comparer.Equals(begin.Read(), searchIter.Read())) { return(begin); } } } return(null); }
public void ReplaceIfTest() { int[] data = { 1, 2, 3 }; using (ForwardIterator <int> inputIterator = new ForwardIterator <int>(data)) { Algorithm.ReplaceIf(inputIterator, delegate(int x) { return(x == 3); }, 2); bool isCorrectData = (inputIterator[0] == 1 && inputIterator[1] == 2 && inputIterator[2] == 2); Assert.IsTrue(isCorrectData); } }
public void RandomShuffle() { int[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16 }; using (IForwardIterator <int> inputIterator = new ForwardIterator <int>(data)) { Algorithm.RandomShuffle(inputIterator); 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); } }
public void GenerateNTest() { using (ForwardIterator <int> inputIterator = new ForwardIterator <int>(3)) { Algorithm.GenerateN(inputIterator, 1, delegate { return(2); }); Assert.IsTrue(inputIterator.Count() == 3); bool isCorrectData = (inputIterator[0] == 2 && inputIterator[1] == 0 && inputIterator[2] == 0); Assert.IsTrue(isCorrectData); } }
[Test] public void AdjacentFind_ForwardIterator() { int[] array = Constants.TEST_INT_ARRAY; ForwardIterator <int> begin = IteratorUtil.Begin(array); ForwardIterator <int> end = IteratorUtil.End(array); ForwardIterator <int> iter = Algorithm.AdjacentFind(begin, end); Assert.AreEqual(6, IteratorUtil.Distance(begin, iter)); Assert.AreEqual(array[6], iter.Read()); iter = Algorithm.AdjacentFind(IteratorUtil.Begin(array), IteratorUtil.End(array), EqualityComparer <int> .Default); Assert.AreEqual(6, IteratorUtil.Distance(begin, iter)); Assert.AreEqual(array[6], iter.Read()); iter = Algorithm.AdjacentFind(IteratorUtil.Begin(array), IteratorUtil.End(array), AreEqual); Assert.AreEqual(6, IteratorUtil.Distance(begin, iter)); Assert.AreEqual(array[6], iter.Read()); }
[Test] public void MinElement_IntIteratorPredicate() { int[] array = Constants.TEST_INT_ARRAY; ListIterator <int> iter = Algorithm.MinElement(IteratorUtil.Begin(array), IteratorUtil.End(array), LessThanInt); Assert.AreEqual(-17, iter.Read()); Assert.AreEqual(4, iter.Position); RandomAccessIterator <int> beginR = IteratorUtil.Begin(array); RandomAccessIterator <int> endR = IteratorUtil.End(array); RandomAccessIterator <int> iterR = Algorithm.MinElement(beginR, endR, LessThanInt); Assert.AreEqual(4, ((ListIterator <int>)iterR).Position); ForwardIterator <int> beginF = IteratorUtil.Begin(array); ForwardIterator <int> endF = IteratorUtil.End(array); ForwardIterator <int> iterF = Algorithm.MinElement(beginF, endF, LessThanInt); Assert.AreEqual(4, ((ListIterator <int>)iterF).Position); }
[Test] public void MaxElement_IntIteratorPredicate() { int[] array = Constants.TEST_INT_ARRAY; ListIterator <int> iter = Algorithm.MaxElement(IteratorUtil.Begin(array), IteratorUtil.End(array), Functional.Compare); Assert.AreEqual(100, iter.Read()); Assert.AreEqual(10, iter.Position); RandomAccessIterator <int> beginR = IteratorUtil.Begin(array); RandomAccessIterator <int> endR = IteratorUtil.End(array); RandomAccessIterator <int> iterR = Algorithm.MaxElement(beginR, endR, Functional.Compare); Assert.AreEqual(10, ((ListIterator <int>)iterR).Position); ForwardIterator <int> beginF = IteratorUtil.Begin(array); ForwardIterator <int> endF = IteratorUtil.End(array); ForwardIterator <int> iterF = Algorithm.MaxElement(beginF, endF, Functional.Compare); Assert.AreEqual(10, ((ListIterator <int>)iterF).Position); }
public void PartitionTest() { int[] data = { 0, 1, 2, 3 }; UnaryPredicate <int> isEven = delegate(int x) { return(x % 2 == 0); }; using (ForwardIterator <int> inputIterator = new ForwardIterator <int>(data)) { Algorithm.Partition(inputIterator, isEven); bool isCorrectData = (inputIterator[0] == 0 && inputIterator[1] == 2 && inputIterator[2] == 1 && inputIterator[3] == 3); Assert.IsTrue(isCorrectData); } }
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 static void RotateCopy <T>(ForwardIterator <T> begin, ForwardIterator <T> middle, ForwardIterator <T> end, OutputIterator <T> dest) { Copy(begin, middle, Copy(middle, end, dest)); #if NEVER dest = IteratorUtil.Clone(dest); ForwardIterator <T> src = IteratorUtil.Clone(newBegin); newBegin = IteratorUtil.Clone(newBegin); for (; !src.Equals(end); dest.MoveNext(), src.MoveNext()) { dest.Write(src.Read()); } src = IteratorUtil.Clone(begin); for (; !src.Equals(newBegin); dest.MoveNext(), src.MoveNext()) { dest.Write(src.Read()); } #endif }
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"); } } }
[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); }