Esempio n. 1
0
        public void Defer <T>([PexAssumeNotNull] IEnumerable <T> source)
        {
            var stateful   = default(StatefulEnumerable <T>);
            var enumerable = EnumerableEx.Defer(() => { stateful = new StatefulEnumerable <T>(source);
                                                        return(stateful); });

            PexAssert.IsNull(stateful);
            var enumerator = enumerable.GetEnumerator();

            PexAssert.IsNotNull(stateful);

            var sourceEnumerator = source.GetEnumerator();

            var expectedState = new List <EnumerableState>()
            {
                EnumerableState.Fresh,
                EnumerableState.CreatingEnumerator,
                EnumerableState.CreatedEnumerator,
                EnumerableState.MovingNext
            };

            if (!sourceEnumerator.MoveNext())
            {
                PexAssert.IsFalse(enumerator.MoveNext());

                expectedState.Add(EnumerableState.AtEnd);
                PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));
            }
            else
            {
                PexAssert.IsTrue(enumerator.MoveNext());

                expectedState.Add(EnumerableState.MovedNext);
                PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));


                expectedState.Add(EnumerableState.GettingCurrent);
                PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current);
                expectedState.Add(EnumerableState.GotCurrent);
                PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));

                var count = 1;
                while (sourceEnumerator.MoveNext())
                {
                    count++;
                    expectedState.Add(EnumerableState.MovingNext);
                    PexAssert.IsTrue(enumerator.MoveNext());
                    expectedState.Add(EnumerableState.MovedNext);
                    PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));

                    expectedState.Add(EnumerableState.GettingCurrent);
                    PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current);
                    expectedState.Add(EnumerableState.GotCurrent);
                    PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));

                    PexAssert.AreEqual(count, stateful.EnumerationCount);
                }
                PexAssert.IsFalse(enumerator.MoveNext());
            }
        }
Esempio n. 2
0
        public void Dematerialize <T>([PexAssumeNotNull] IEnumerable <Notification <T> > source)
        {
            PexAssume.AreElementsNotNull(source);

            var dispatched = source.Dematerialize();
            var enumerable = new StatefulEnumerable <T>(dispatched)
            {
                ShouldRethrow = false
            };
            var enumerator       = enumerable.GetEnumerator();
            var sourceEnumerator = source.GetEnumerator();

            while (sourceEnumerator.MoveNext())
            {
                var notification = sourceEnumerator.Current;
                var onNext       = notification as Notification <T> .OnNext;
                if (onNext != null)
                {
                    PexAssert.IsTrue(enumerator.MoveNext());
                    PexAssert.AreEqual(EnumerableState.MovedNext, enumerable.CurrentState);
                    PexAssert.AreEqual(onNext.Value, enumerator.Current);
                    PexAssert.AreEqual(EnumerableState.GotCurrent, enumerable.CurrentState);
                }
                else
                {
                    var onError = notification as Notification <T> .OnError;
                    if (onError != null)
                    {
                        PexAssert.IsFalse(enumerator.MoveNext());
                        PexAssert.AreEqual(EnumerableState.MovingNext | EnumerableState.Threw, enumerable.CurrentState);
                        PexAssert.AreEqual(onError.Exception, enumerable.Exception);
                        return;
                    }
                    var onCompleted = (Notification <T> .OnCompleted)notification;
                    PexAssert.IsFalse(enumerator.MoveNext());
                    PexAssert.AreEqual(EnumerableState.AtEnd, enumerable.CurrentState);
                    return;
                }
            }
            PexAssert.IsFalse(enumerator.MoveNext());
        }
Esempio n. 3
0
 public StatefulEnumerator(StatefulEnumerable <T> statefulEnumerable, IEnumerator <T> source)
 {
     m_source             = source;
     m_statefulEnumerable = statefulEnumerable;
 }