Example #1
0
        public void TestCollectionUnwrap()
        {
            var l = new Live<int>[0].ToCollection().ToLiveCollection();

            l.Unwrap().ToIndependent().States().Take(1).Check(
                () => { },
                state =>
                {
                    var s = state.Single();
                    Debug.Assert(s.Status == StateStatus.Connecting);
                    Debug.Assert(s.Inner.SequenceEqual(new int[] { }));
                    Debug.Assert(s.Delta == null);
                });

            l.Unwrap().ToIndependent().States().Skip(1).Take(1).Check(
                () => l.PublishInner.Add(1.ToLive()),
                state =>
                {
                    var s = state.Single();
                    Debug.Assert(s.Status == StateStatus.Connected);
                    Debug.Assert(s.Delta.HasChange());
                    Debug.Assert(s.Inner.UnorderedEqual(new[] { 1 }));
                    Debug.Assert(s.Delta.Inserts.UnorderedEqual(new[] { 1 }));
                });

            l.Unwrap().ToIndependent().States().Skip(1).Take(1).Check(
                () => l.PublishInner.Add(2.ToLive()),
                state =>
                {
                    var s = state.Single();
                    Debug.Assert(s.Status == StateStatus.Connected);
                    Debug.Assert(s.Delta.HasChange());
                    Debug.Assert(s.Inner.UnorderedEqual(new[] { 1, 2 }));
                    Debug.Assert(s.Delta.Inserts.UnorderedEqual(new[] { 2 }));
                });

            l.Unwrap().ToIndependent().States().Skip(1).Take(1).Check(
                () => l.PublishInner.Single(i => i.Value == 2).PublishValue = 3,
                state =>
                {
                    var s = state.Single();
                    Debug.Assert(s.Status == StateStatus.Connected);
                    Debug.Assert(s.Delta.HasChange());
                    Debug.Assert(s.Inner.UnorderedEqual(new[] { 1, 3 }));
                    Debug.Assert(s.Delta.Inserts.UnorderedEqual(new[] { 3 }));
                    Debug.Assert(s.Delta.Deletes.UnorderedEqual(new[] { 2 }));
                });

            l.Unwrap().ToIndependent().States().Skip(1).Take(1).Check(
                () => l.PublishInner.Remove(l.PublishInner.Single(i => i.Value == 3)),
                state =>
                {
                    var s = state.Single();
                    Debug.Assert(s.Status == StateStatus.Connected);
                    Debug.Assert(s.Delta.HasChange());
                    Debug.Assert(s.Inner.UnorderedEqual(new[] { 1 }));
                    Debug.Assert(s.Delta.Deletes.UnorderedEqual(new[] { 3 }));
                });

            l.Unwrap().ToIndependent().States().Skip(1).Take(1).Check(
                () => l.PublishInner.Remove(l.PublishInner.Single(i => i.Value == 1)),
                state =>
                {
                    var s = state.Single();
                    Debug.Assert(s.Status == StateStatus.Connected);
                    Debug.Assert(s.Delta.HasChange());
                    Debug.Assert(s.Inner.UnorderedEqual(new int[0]));
                    Debug.Assert(s.Delta.Deletes.UnorderedEqual(new[] { 1 }));
                });
        }