public async void Container_Should_TriggerOnCount_With_Count()
        {
            var calculator = new StandardDeviationCalculator(3);
            var trigger    = new TriggerSettings(2, 202);
            var range      = new DetectionRange <double>(300, 800, 1000, 1200, 1700);
            var container  = new ValueContainer <double>(calculator, trigger, range);

            var    anomalyLowTriggeredCounter   = 0;
            var    anomalyHighTriggeredCounter  = 0;
            var    valueChangedTriggeredCounter = 0;
            double value        = 0;
            var    triggerValue = Trigger.None;

            container.AnomalyEvent += (object _, AnomalyEventArgs <double> e) =>
            {
                if (e.Anomaly == Anomaly.Low)
                {
                    anomalyLowTriggeredCounter++;
                }
                else if (e.Anomaly == Anomaly.High)
                {
                    anomalyHighTriggeredCounter++;
                }
            };

            container.ValueChangedEvent += (object _, ValueChangedEventArgs <double> e) =>
            {
                valueChangedTriggeredCounter++;
                value        = e.Value;
                triggerValue = e.Trigger;
            };

            for (var i = 700; i <= 900; i++)
            {
                await container.AddAsync(i).ConfigureAwait(false);
            }

            anomalyLowTriggeredCounter.Should().Be(0);
            anomalyHighTriggeredCounter.Should().Be(0);
            valueChangedTriggeredCounter.Should().Be(0);

            await container.AddAsync(800).ConfigureAwait(false);

            anomalyLowTriggeredCounter.Should().Be(0);
            anomalyHighTriggeredCounter.Should().Be(0);
            valueChangedTriggeredCounter.Should().Be(1);
            value.Should().Be(800);
            triggerValue.Should().Be(Trigger.Count);

            await container.AddAsync(800).ConfigureAwait(false);

            await container.AddAsync(900).ConfigureAwait(false);

            valueChangedTriggeredCounter.Should().Be(2);
            value.Should().Be(850);
            triggerValue.Should().Be(Trigger.Count);
        }
        public void TestCalculateWithDate()
        {
            var closingPrices = this.SetupClosingPrices();

            var expectedResult = new Dictionary<DateTime, decimal>
                {
                    {new DateTime(2009, 6, 29), 1.60m},
                    {new DateTime(2009, 6, 30), 1.55m}
                };

            var calculator = new StandardDeviationCalculator(closingPrices, 20);
            var result = calculator.CalculateAsync(new DateTime(2009, 6, 29)).Result;
            Assert.AreEqual(expectedResult, result);
        }