Example #1
0
        public void TakeWhile4(int startFrom, int count)
        {
            Func <int, bool> takeWhilePredicate = i => i < 20;
            Func <int, int>  select1            = i => i * 3;
            Func <int, int>  select2            = i => i * 5;
            Func <int, int>  select3            = i => i * 7;
            Func <int, int>  select4            = i => i * 11;

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3).ToArray()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3).Select(select4),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3).Select(select4)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3).Select(select4),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).TakeWhile(takeWhilePredicate).Select(select3).Select(select4).ToArray()
                );
        }
Example #2
0
        public void Select(int startFrom, int count)
        {
            Func <int, int> select1 = i => i * 3;
            Func <int, int> select2 = i => i * 5;
            Func <int, int> select3 = i => i * 7;
            Func <int, int> select4 = i => i * 11;

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1),
                LowCostEnumerable.Range(startFrom, count).Select(select1)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1),
                LowCostEnumerable.Range(startFrom, count).Select(select1).ToArray()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).ToArray()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3).ToArray()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3).Select(select4),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3).Select(select4)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3).Select(select4),
                LowCostEnumerable.Range(startFrom, count).Select(select1).Select(select2).Select(select3).Select(select4).ToArray()
                );
        }
 public void LowCostEnumerableMethods()
 {
     Assert.Throws <ArgumentOutOfRangeException>(() => LowCostEnumerable.Range(0, -1));
     Assert.Throws <ArgumentOutOfRangeException>(() => LowCostEnumerable.Range(1, Int32.MaxValue));
     Assert.Throws <ArgumentOutOfRangeException>(() => LowCostEnumerable.Range(10, Int32.MaxValue));
 }
Example #4
0
        public void Where(int startFrom, int count)
        {
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count),
                LowCostEnumerable.Range(startFrom, count)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count),
                LowCostEnumerable.Range(startFrom, count).ToArray()
                );
            Assert.AreEqual(
                Enumerable.Range(startFrom, count).FirstOrDefault(),
                LowCostEnumerable.Range(startFrom, count).FirstOrDefault()
                );

            Func <int, bool> predicate1 = i => i != 1 && i != 2;
            Func <int, bool> predicate2 = i => i != 3 && i != 4;
            Func <int, bool> predicate3 = i => i != 5 && i != 6;
            Func <int, bool> predicate4 = i => i != 7 && i != 8;

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).ToArray()
                );
            Assert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).FirstOrDefault(),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).FirstOrDefault()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).ToArray()
                );
            Assert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).FirstOrDefault(),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).FirstOrDefault()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).ToArray()
                );
            Assert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).FirstOrDefault(),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).FirstOrDefault()
                );

            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).Where(predicate4),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).Where(predicate4)
                );
            CollectionAssert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).Where(predicate4),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).Where(predicate4).ToArray()
                );
            Assert.AreEqual(
                Enumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).Where(predicate4).FirstOrDefault(),
                LowCostEnumerable.Range(startFrom, count).Where(predicate1).Where(predicate2).Where(predicate3).Where(predicate4).FirstOrDefault()
                );
        }
Example #5
0
 public void Range(int startFrom, int count)
 {
     LowCostEnumerable.Range(startFrom, count);
 }