Ejemplo n.º 1
0
        public static void TakeWhile_Indexed_NotPipelined(Labeled <ParallelQuery <int> > labeled, int count, int take)
        {
            ParallelQuery <int> query = labeled.Item;
            int seen = 0;

            Assert.All(query.TakeWhile((x, index) => index < take).ToList(), x => Assert.Equal(seen++, x));
            Assert.Equal(Math.Min(count, Math.Max(0, take)), seen);
        }
Ejemplo n.º 2
0
        public static void TakeWhile_SomeFalse(Labeled <ParallelQuery <int> > labeled, int count, IEnumerable <int> take)
        {
            ParallelQuery <int> query = labeled.Item;
            int seen = 0;

            Assert.All(query.TakeWhile(x => !take.Contains(x)), x => Assert.Equal(seen++, x));
            Assert.Equal(take.Min(), seen);
        }
Ejemplo n.º 3
0
        public static void TakeWhile_AllTrue(Labeled <ParallelQuery <int> > labeled, int count, int take)
        {
            ParallelQuery <int> query = labeled.Item;
            int seen = 0;

            Assert.All(query.TakeWhile(x => true), x => Assert.Equal(seen++, x));
            Assert.Equal(count, seen);
        }
Ejemplo n.º 4
0
        public static void TakeWhile_SomeTrue(Labeled <ParallelQuery <int> > labeled, int count, int[] take)
        {
            ParallelQuery <int> query = labeled.Item;
            int seen = 0;

            Assert.All(query.TakeWhile(x => take.Contains(x)), x => Assert.Equal(seen++, x));
            Assert.Equal(take.Min() > 0 ? 0 : take.Max() + 1, seen);
        }
Ejemplo n.º 5
0
        public static void TakeWhile_Indexed_Unordered_NotPipelined(Labeled <ParallelQuery <int> > labeled, int count, int take)
        {
            ParallelQuery <int> query = labeled.Item;
            // For unordered collections, which elements (if any) are taken isn't actually guaranteed, but an effect of the implementation.
            // If this test starts failing it should be updated, and possibly mentioned in release notes.
            IntegerRangeSet seen = new IntegerRangeSet(0, Math.Min(count, Math.Max(0, take)));

            Assert.All(query.TakeWhile((x, index) => index < take).ToList(), x => seen.Add(x));
            seen.AssertComplete();
        }
Ejemplo n.º 6
0
        public static void TakeWhile_Indexed(Labeled <ParallelQuery <int> > labeled, int count, int take)
        {
            ParallelQuery <int> query = labeled.Item;
            int seen = 0;

            foreach (int i in query.TakeWhile((x, index) => index < take))
            {
                Assert.Equal(seen++, i);
            }
            Assert.Equal(Math.Min(count, Math.Max(0, take)), seen);
        }
Ejemplo n.º 7
0
        internal static ParallelQuery <int> MakeTakeWhileIndexed(bool orderPreserved)
        {
            int[] a = Enumerable.Range(0, 110).ToArray();

            ParallelQuery <int> ipe = a.AsParallel();

            if (orderPreserved)
            {
                ipe = ipe.AsOrdered();
            }

            return(ipe.TakeWhile((i, j) => j < 100));
        }
Ejemplo n.º 8
0
        public static void TakeWhile_Unordered(Labeled <ParallelQuery <int> > labeled, int count, int take)
        {
            ParallelQuery <int> query = labeled.Item;
            // For unordered collections, which elements (if any) are taken isn't actually guaranteed, but an effect of the implementation.
            // If this test starts failing it should be updated, and possibly mentioned in release notes.
            IntegerRangeSet seen = new IntegerRangeSet(0, Math.Min(count, Math.Max(0, take)));

            foreach (int i in query.TakeWhile(x => x < take))
            {
                seen.Add(i);
            }
            seen.AssertComplete();
        }
Ejemplo n.º 9
0
        private static void RunAllTests(
            TestTracker result, ParallelQuery <int> q, bool orderPreserved,
            string leftOpName, bool leftOrderDefined)
        {
            LogTestRun(leftOpName, "All1", orderPreserved);
            result.MustEqual(
                q.All(i => i > 100),
                q.ToArray().Any(i => i > 100));

            LogTestRun(leftOpName, "All2", orderPreserved);
            result.MustEqual(
                q.All(i => i == 75),
                q.ToArray().All(i => i == 75));

            LogTestRun(leftOpName, "Any1", orderPreserved);
            result.MustEqual(
                q.Any(i => i > 100),
                q.ToArray().Any(i => i > 100));

            LogTestRun(leftOpName, "Any2", orderPreserved);
            result.MustEqual(
                q.Any(i => i == 75),
                q.ToArray().Any(i => i == 75));

            LogTestRun(leftOpName, "Concat", orderPreserved);
            result.MustSequenceEqual(
                q.Concat(q).Concat(new int[] { 1, 2, 3 }.AsParallel()),
                q.Reverse().Reverse().ToArray().Concat(q.Reverse().Reverse()).Concat(new int[] { 1, 2, 3 }),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "DefaultIfEmpty", orderPreserved);
            result.MustSequenceEqual(
                q.DefaultIfEmpty(),
                q.ToArray().DefaultIfEmpty(), orderPreserved && leftOrderDefined);

            LogTestRun(leftOpName, "ElementAt", orderPreserved);
            IEnumerable <int> q2 = q.ToArray();
            int        count1 = q.Count(), count2 = q2.Count();
            List <int> list1 = new List <int>();
            List <int> list2 = new List <int>();

            for (int i = 0; i < count1; i++)
            {
                list1.Add(q.ElementAt(i));
            }
            for (int i = 0; i < count2; i++)
            {
                list2.Add(q2.ElementAt(i));
            }
            result.MustSequenceEqual(list1, list2, leftOrderDefined);

            LogTestRun(leftOpName, "Except", orderPreserved);
            result.MustSequenceEqual(
                q.Except(Enumerable.Range(90, 50).AsParallel()),
                q.ToArray().Except(Enumerable.Range(90, 50)),
                false);

            LogTestRun(leftOpName, "First", orderPreserved);
            CheckFirstOrLast(
                result,
                q.First(),
                q.ToArray().First(),
                leftOrderDefined);

            LogTestRun(leftOpName, "GroupBy", orderPreserved);
            result.MustGroupByEqual(
                q.GroupBy(i => i % 5, (i, e) => new Pair <int, IEnumerable <int> >(i, e)),
                q.ToArray().GroupBy(i => i % 5, (i, e) => new Pair <int, IEnumerable <int> >(i, e)));

            LogTestRun(leftOpName, "GroupJoin", orderPreserved);
            result.MustSequenceEqual(
                q.GroupJoin(q, i => i, i => i, (i, e) => e.FirstOrDefault()),
                q.ToArray().GroupJoin(q.ToArray(), i => i, i => i, (i, e) => e.FirstOrDefault()),
                false);

            LogTestRun(leftOpName, "Intersect", orderPreserved);
            result.MustSequenceEqual(
                q.Intersect(Enumerable.Range(90, 50).AsParallel()),
                q.ToArray().Intersect(Enumerable.Range(90, 50)),
                false);

            LogTestRun(leftOpName, "Join1", orderPreserved);
            result.MustSequenceEqual(
                q.Join((new int[] { 1, 1, 2, 3, 3 }).AsParallel(), i => i, i => i, (i, j) => i + j),
                q.ToArray().Join(new int[] { 1, 1, 2, 3, 3 }, i => i, i => i, (i, j) => i + j),
                false);

            LogTestRun(leftOpName, "Join2", orderPreserved);
            result.MustSequenceEqual(
                q.Join((new int[] { 1, 1, 100, 3, 3 }).AsParallel(), i => new String('a', i), i => new String('a', i), (i, j) => i + j),
                q.ToArray().Join(new int[] { 1, 1, 100, 3, 3 }, i => new String('a', i), i => new String('a', i), (i, j) => i + j),
                false);

            LogTestRun(leftOpName, "Last", orderPreserved);
            CheckFirstOrLast(
                result,
                q.Last(),
                q.ToArray().Last(),
                leftOrderDefined);

            LogTestRun(leftOpName, "Min", orderPreserved);
            CheckFirstOrLast(
                result,
                q.Min(),
                q.ToArray().Min(),
                leftOrderDefined);

            LogTestRun(leftOpName, "Max", orderPreserved);
            CheckFirstOrLast(
                result,
                q.Min(),
                q.ToArray().Min(),
                leftOrderDefined);

            LogTestRun(leftOpName, "OrderBy-ThenBy", orderPreserved);
            result.MustSequenceEqual(
                q.Concat(q).OrderBy(i => i % 5).ThenBy(i => - i),
                q.ToArray().Concat(q).OrderBy(i => i % 5).ThenBy(i => - i),
                true);

            LogTestRun(leftOpName, "OrderByDescending-ThenByDescending", orderPreserved);
            result.MustSequenceEqual(
                q.Concat(q).OrderByDescending(i => i % 5).ThenByDescending(i => - i),
                q.ToArray().Concat(q).OrderByDescending(i => i % 5).ThenByDescending(i => - i),
                true);

            LogTestRun(leftOpName, "Reverse", orderPreserved);
            result.MustSequenceEqual(
                q.Concat(q).Reverse(),
                q.ToArray().Concat(q).Reverse(),
                orderPreserved && leftOrderDefined);

            LogTestRun(leftOpName, "Select", orderPreserved);
            result.MustSequenceEqual(
                q.Select(i => 5 * i - 17),
                q.ToArray().Select(i => 5 * i - 17),
                orderPreserved && leftOrderDefined);

            LogTestRun(leftOpName, "SelectMany", orderPreserved);
            result.MustSequenceEqual(
                q.SelectMany(i => new int[] { 1, 2, 3 }, (i, j) => i + 100 * j),
                q.ToArray().SelectMany(i => new int[] { 1, 2, 3 }, (i, j) => i + 100 * j),
                false);

            LogTestRun(leftOpName, "SequenceEqual", orderPreserved);
            if (orderPreserved && leftOrderDefined)
            {
                result.MustEqual(q.SequenceEqual(q), true);
            }
            else
            {
                // We don't check the return value as it can be either true or false
                q.SequenceEqual(q);
            }

            LogTestRun(leftOpName, "Skip", orderPreserved);
            CheckTakeSkip(
                result,
                q.Skip(10),
                q.ToArray().Skip(10),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "SkipWhile", orderPreserved);
            CheckTakeSkip(
                result,
                q.SkipWhile(i => i < 30),
                q.ToArray().SkipWhile(i => i < 30),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "SkipWhileIndexed", orderPreserved);
            CheckTakeSkip(
                result,
                q.SkipWhile((i, j) => j < 30),
                q.ToArray().SkipWhile((i, j) => j < 30),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "Take", orderPreserved);
            CheckTakeSkip(
                result,
                q.Take(10),
                q.ToArray().Take(10),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "TakeWhile", orderPreserved);
            CheckTakeSkip(
                result,
                q.TakeWhile(i => i < 30),
                q.ToArray().TakeWhile(i => i < 30),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "TakeWhileIndexed", orderPreserved);
            CheckTakeSkip(
                result,
                q.TakeWhile((i, j) => j < 30),
                q.ToArray().TakeWhile((i, j) => j < 30),
                leftOrderDefined && orderPreserved);

            LogTestRun(leftOpName, "Union", orderPreserved);
            result.MustSequenceEqual(
                q.Union(Enumerable.Range(90, 50).AsParallel()),
                q.ToArray().Union(Enumerable.Range(90, 50)),
                false);

            LogTestRun(leftOpName, "Where", orderPreserved);
            result.MustSequenceEqual(
                q.Where(i => i < 20 || i > 80),
                q.ToArray().Where(i => i < 20 || i > 80),
                orderPreserved && leftOrderDefined);

            LogTestRun(leftOpName, "Zip", orderPreserved);
            IEnumerable <KeyValuePair <int, int> > zipQ = q.Zip(q, (i, j) => new KeyValuePair <int, int>(i, j));

            result.MustSequenceEqual(
                zipQ.Select(p => p.Key),
                q.Reverse().Reverse().ToArray(),
                orderPreserved && leftOrderDefined);
            result.MustSequenceEqual(
                zipQ.Select(p => p.Value),
                q.Reverse().Reverse().ToArray(),
                orderPreserved && leftOrderDefined);
        }
Ejemplo n.º 10
0
        public static void TakeWhile_AllFalse(Labeled <ParallelQuery <int> > labeled, int count, int take)
        {
            ParallelQuery <int> query = labeled.Item;

            Assert.Empty(query.TakeWhile(x => false));
        }