public void WontRemoveEnumeratorsReturningTrueWithCurrentNull()
        {
            var time      = new DateTime(2016, 03, 03, 12, 05, 00);
            var tradeBar1 = new TradeBar {
                Symbol = Symbols.SPY, Time = time
            };
            var tradeBar2 = new TradeBar {
                Symbol = Symbols.AAPL, Time = time, Open = 23
            };
            var stream1 = Enumerable.Range(0, 20)
                          // return null except the last value and check if its emitted
                          .Select(x => x == 19 ? new Slice(time.AddSeconds(x * 1), new BaseData[] { tradeBar1, tradeBar2 }, utcTime: time.AddSeconds(x * 1)) : null
                                  ).GetEnumerator();
            var stream2 = Enumerable.Range(0, 5).Select(x => new Slice(time.AddSeconds(x * 2), new List <BaseData>(), utcTime: time.AddSeconds(x * 2))).GetEnumerator();
            var stream3 = Enumerable.Range(0, 20).Select(x => new Slice(time.AddSeconds(x * 0.5), new List <BaseData>(), utcTime: time.AddSeconds(x * 0.5))).GetEnumerator();

            var previous     = new Slice(DateTime.MinValue, new List <BaseData>(), DateTime.MinValue);
            var synchronizer = new SynchronizingSliceEnumerator(stream1, stream2, stream3);

            while (synchronizer.MoveNext())
            {
                Assert.That(synchronizer.Current.UtcTime, Is.GreaterThanOrEqualTo(previous.UtcTime));
                previous = synchronizer.Current;
            }
            Assert.AreEqual(2, previous.Bars.Count);
            synchronizer.Dispose();
        }
        public void WillStopIfAllEnumeratorsCurrentIsNullAndReturningFalse()
        {
            var stream1 = new TestEnumerator {
                MoveNextReturnValue = false
            };
            var synchronizer = new SynchronizingSliceEnumerator(stream1);

            while (synchronizer.MoveNext())
            {
                Assert.Fail();
            }
            Assert.IsTrue(stream1.MoveNextWasCalled);
            synchronizer.Dispose();
        }
        public void SynchronizesData()
        {
            var time    = new DateTime(2016, 03, 03, 12, 05, 00);
            var stream1 = Enumerable.Range(0, 10).Select(x => new Slice(time.AddSeconds(x * 1), new List <BaseData>(), utcTime: time.AddSeconds(x * 1))).GetEnumerator();
            var stream2 = Enumerable.Range(0, 5).Select(x => new Slice(time.AddSeconds(x * 2), new List <BaseData>(), utcTime: time.AddSeconds(x * 2))).GetEnumerator();
            var stream3 = Enumerable.Range(0, 20).Select(x => new Slice(time.AddSeconds(x * 0.5), new List <BaseData>(), utcTime: time.AddSeconds(x * 0.5))).GetEnumerator();

            var previous     = DateTime.MinValue;
            var synchronizer = new SynchronizingSliceEnumerator(stream1, stream2, stream3);

            while (synchronizer.MoveNext())
            {
                Assert.That(synchronizer.Current.UtcTime, Is.GreaterThanOrEqualTo(previous));
                previous = synchronizer.Current.UtcTime;
            }
            synchronizer.Dispose();
        }
        public void WillRemoveEnumeratorsReturningFalse()
        {
            var time    = new DateTime(2016, 03, 03, 12, 05, 00);
            var stream1 = new TestEnumerator {
                MoveNextReturnValue = false
            };
            var stream2      = Enumerable.Range(0, 10).Select(x => new Slice(time.AddSeconds(x * 0.5), new List <BaseData>(), utcTime: time.AddSeconds(x * 0.5))).GetEnumerator();
            var synchronizer = new SynchronizingSliceEnumerator(stream1, stream2);
            var emitted      = false;

            while (synchronizer.MoveNext())
            {
                emitted = true;
            }
            Assert.IsTrue(emitted);
            Assert.IsTrue(stream1.MoveNextWasCalled);
            Assert.AreEqual(1, stream1.MoveNextCallCount);
            synchronizer.Dispose();
        }