public void Stop_DisposesCurrentlyExecutingObservable()
        {
            var disposable = LiveSequence.Start(s =>
            {
                s.AddAction(() => _value = 1);
                s.Add(CreateTimer(10).DoOnCompleted(() => _value = 2));
                s.Add(() =>
                {
                    _value = 3;
                    return(CreateTimer(10)
                           .DoOnCompleted(() => _value = 4)
                           .DoOnCancel(() => _value = 100));
                });
                s.Add(CreateTimer(10).DoOnCompleted(() => _value = 5));
                s.AddAction(() => _value = 6);
            });

            AssertValue(1);

            _scheduler.AdvanceTo(10);
            AssertValue(3);

            disposable.Dispose();
            AssertValue(100);

            _scheduler.AdvanceTo(1000);
            AssertValue(100);
        }
        public void SubscribeAfterDisposeOfPreviousSubscription_ExecutionResumesInstantlyWithNextItem()
        {
            var seq = LiveSequence.Create(s =>
            {
                s.Add(CreateTimer(10).DoOnCompleted(() => _value = 1));
                s.Add(() =>
                {
                    _value = 2;
                    return(CreateTimer(10).DoOnCancel(() => _value = 3));
                });
                s.Add(() =>
                {
                    _value = 4;
                    return(CreateTimer(10));
                });
                s.AddAction(() => _value = 5);
            });
            var disposable = seq.Subscribe();

            AssertValue(0);

            _scheduler.AdvanceTo(10);
            AssertValue(2);

            disposable.Dispose();
            AssertValue(3);

            _scheduler.AdvanceTo(1000);
            AssertValue(3);

            seq.Subscribe();
            AssertValue(4);

            _scheduler.AdvanceBy(10);
            AssertValue(5);
        }
 public void Static_Create_DoesNotStartSequencer()
 {
     LiveSequence.Create(s => s.AddAction(() => _value = 123));
     AssertValue(0);
 }
 public void Static_Start_DoesStartSequencer()
 {
     LiveSequence.Start(s => s.AddAction(() => _value = 123));
     AssertValue(123);
 }
 public override void Setup()
 {
     base.Setup();
     _liveSequence = new LiveSequence();
 }