public void ChangingASerializableItemShouldChangeTheContentHash(string[] items, int toChange, string newValue)
        {
            PexAssume.IsNotNullOrEmpty(items);
            PexAssume.TrueForAll(items, x => x != null);
            PexAssume.AreDistinctReferences(items);
            PexAssume.IsTrue(toChange >= 0 && toChange < items.Length);

            (new TestScheduler()).With(sched => {
                var fixture = new SerializedCollection <ModelTestFixture>(
                    items.Select(x => new ModelTestFixture()
                {
                    TestString = x
                }));
                bool shouldDie = true;
                var hashBefore = fixture.ContentHash;
                PexAssume.AreNotEqual(newValue, fixture[toChange].TestString);

                fixture.Changed.Subscribe(_ => shouldDie = false);
                Observable.Return(newValue, sched).Subscribe(x => fixture[toChange].TestString = x);

                sched.Start();

                PexAssert.AreNotEqual(hashBefore, fixture.ContentHash);
                PexAssert.IsFalse(shouldDie);
            });
        }
Exemplo n.º 2
0
        public void Share()
        {
            var source           = Enumerable.Range(0, 10).Share();
            var firstEnumerator  = source.GetEnumerator();
            var secondEnumerator = source.GetEnumerator();

            PexAssert.AreNotEqual(firstEnumerator, secondEnumerator);

            for (var i = 0; i < 5; i++)
            {
                PexAssert.IsTrue(firstEnumerator.MoveNext());
                PexAssert.IsTrue(secondEnumerator.MoveNext());

                var offset = i * 2;
                PexAssert.AreEqual(offset, firstEnumerator.Current);
                PexAssert.AreEqual(offset + 1, secondEnumerator.Current);
            }
            PexAssert.IsFalse(firstEnumerator.MoveNext());
            PexAssert.IsFalse(secondEnumerator.MoveNext());
        }
Exemplo n.º 3
0
        private static void RemotableCallBack()
        {
            var source = (int[])AppDomain.CurrentDomain.GetData("sourceData");
            var remote = (IEnumerable <Tuple <int, int> >)AppDomain.CurrentDomain.GetData("testEnum");

            var otherDomain = (int)AppDomain.CurrentDomain.GetData("otherDomain");

            PexAssert.AreNotEqual(AppDomain.CurrentDomain.Id, otherDomain);

            var enumerable = remote.Select(x => Tuple.Create(x, AppDomain.CurrentDomain.Id));
            var enumerator = enumerable.GetEnumerator();

            foreach (var value in source)
            {
                PexAssert.IsTrue(enumerator.MoveNext());
                var item = enumerator.Current;
                PexAssert.AreEqual(value, item.First.First);
                PexAssert.AreEqual(AppDomain.CurrentDomain.Id, item.Second);
                PexAssert.AreEqual(otherDomain, item.First.Second);
            }
            PexAssert.IsFalse(enumerator.MoveNext());
        }