volume indicators

2026-08-25 05:48:06 +00:00 · 2026-01-30 12:47:25 -08:00
parent 76d2b50cbb
commit 7b3a6520d2
99 changed files with 9539 additions and 283 deletions
@@ -0,0 +1,313 @@
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class VoIndicatorTests
+{
+    [Fact]
+    public void VoIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new VoIndicator();
+
+        Assert.Equal("VO - Volume Oscillator", indicator.Name);
+        Assert.True(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+        Assert.Equal(5, indicator.ShortPeriod);
+        Assert.Equal(10, indicator.LongPeriod);
+        Assert.Equal(10, indicator.SignalPeriod);
+        Assert.Equal(10, indicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void VoIndicator_ShortName_ReflectsPeriods()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 7, SignalPeriod = 5 };
+        Assert.Equal("VO(3,7,5)", indicator.ShortName);
+    }
+
+    [Fact]
+    public void VoIndicator_MinHistoryDepths_EqualsLongPeriod()
+    {
+        var indicator = new VoIndicator { LongPeriod = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void VoIndicator_Periods_CanBeSet()
+    {
+        var indicator = new VoIndicator
+        {
+            ShortPeriod = 12,
+            LongPeriod = 26,
+            SignalPeriod = 9
+        };
+
+        Assert.Equal(12, indicator.ShortPeriod);
+        Assert.Equal(26, indicator.LongPeriod);
+        Assert.Equal(9, indicator.SignalPeriod);
+    }
+
+    [Fact]
+    public void VoIndicator_Initialize_CreatesInternalVo()
+    {
+        var indicator = new VoIndicator();
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist (VO + Signal)
+        Assert.Equal(2, indicator.LinesSeries.Count);
+    }
+
+    [Fact]
+    public void VoIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 5, LongPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            double volume = 100000 + i * 1000;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 105, volume);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        double signalVal = indicator.LinesSeries[1].GetValue(0);
+
+        Assert.True(double.IsFinite(voVal));
+        Assert.True(double.IsFinite(signalVal));
+    }
+
+    [Fact]
+    public void VoIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 5, LongPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 30; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 105, 100000);
+        }
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Add new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(30), 105, 115, 100, 112, 80000);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+        Assert.Equal(2, indicator.LinesSeries[1].Count);
+    }
+
+    [Fact]
+    public void VoIndicator_ConstantVolume_ZeroOscillator()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // All bars with same volume
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, 50000);
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.Equal(0, voVal, 1);
+    }
+
+    [Fact]
+    public void VoIndicator_IncreasingVolume_PositiveOscillator()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Volume increases over time - short MA will exceed long MA
+        for (int i = 0; i < 20; i++)
+        {
+            double volume = 10000 + i * 5000; // Increasing volume
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(voVal > 0, $"VO should be positive when volume increasing: {voVal}");
+    }
+
+    [Fact]
+    public void VoIndicator_DecreasingVolume_NegativeOscillator()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Volume decreases over time - short MA will be below long MA
+        for (int i = 0; i < 20; i++)
+        {
+            double volume = 100000 - i * 4000; // Decreasing volume
+            volume = Math.Max(volume, 1000); // Keep positive
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(voVal < 0, $"VO should be negative when volume decreasing: {voVal}");
+    }
+
+    [Fact]
+    public void VoIndicator_SignalLine_SmoothsVo()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        var voValues = new List<double>();
+        var signalValues = new List<double>();
+
+        // Add oscillating volume
+        for (int i = 0; i < 30; i++)
+        {
+            double volume = 50000 + (i % 2 == 0 ? 20000 : -10000);
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+
+            if (i >= 10) // After warmup
+            {
+                voValues.Add(indicator.LinesSeries[0].GetValue(0));
+                signalValues.Add(indicator.LinesSeries[1].GetValue(0));
+            }
+        }
+
+        // Signal line should be smoother (smaller range)
+        double voRange = voValues.Max() - voValues.Min();
+        double signalRange = signalValues.Max() - signalValues.Min();
+
+        Assert.True(signalRange <= voRange, $"Signal should be smoother: VO range={voRange}, Signal range={signalRange}");
+    }
+
+    [Fact]
+    public void VoIndicator_DifferentPeriods_DifferentResults()
+    {
+        var shortPeriods = new VoIndicator { ShortPeriod = 3, LongPeriod = 6, SignalPeriod = 3 };
+        shortPeriods.Initialize();
+
+        var longPeriods = new VoIndicator { ShortPeriod = 10, LongPeriod = 20, SignalPeriod = 10 };
+        longPeriods.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Add same data to both
+        for (int i = 0; i < 50; i++)
+        {
+            double volume = 50000 + Math.Sin(i * 0.3) * 20000;
+            shortPeriods.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+            longPeriods.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            shortPeriods.ProcessUpdate(args);
+            longPeriods.ProcessUpdate(args);
+        }
+
+        double shortVal = shortPeriods.LinesSeries[0].GetValue(0);
+        double longVal = longPeriods.LinesSeries[0].GetValue(0);
+
+        // Different periods should produce different results
+        Assert.NotEqual(shortVal, longVal, 3);
+    }
+
+    [Fact]
+    public void VoIndicator_ReturnsPercentage()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 2, LongPeriod = 4, SignalPeriod = 2 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Start with baseline volume
+        for (int i = 0; i < 5; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, 10000);
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Add bar with significantly higher volume
+        indicator.HistoricalData.AddBar(now.AddMinutes(5), 100, 105, 95, 100, 20000);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        double voVal = indicator.LinesSeries[0].GetValue(0);
+
+        // VO should be positive percentage (short MA > long MA)
+        Assert.True(voVal > 0, $"VO should be positive: {voVal}");
+        Assert.True(voVal <= 200, $"VO should be reasonable percentage: {voVal}"); // Not too extreme
+    }
+
+    [Fact]
+    public void VoIndicator_OscillatesAroundZero()
+    {
+        var indicator = new VoIndicator { ShortPeriod = 5, LongPeriod = 10, SignalPeriod = 5 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        bool hasPositive = false;
+        bool hasNegative = false;
+
+        // Oscillating volume pattern
+        for (int i = 0; i < 50; i++)
+        {
+            double volume = 50000 + Math.Sin(i * 0.5) * 30000;
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100, 105, 95, 100, volume);
+
+            var args = i == 0
+                ? new UpdateArgs(UpdateReason.HistoricalBar)
+                : new UpdateArgs(UpdateReason.NewBar);
+            indicator.ProcessUpdate(args);
+
+            if (i > 15) // After warmup
+            {
+                double val = indicator.LinesSeries[0].GetValue(0);
+                if (val > 0.5)
+                {
+                    hasPositive = true;
+                }
+                if (val < -0.5)
+                {
+                    hasNegative = true;
+                }
+            }
+        }
+
+        Assert.True(hasPositive && hasNegative, "VO should oscillate around zero");
+    }
+}