Add unit tests for various indicators and update project file

- Implemented unit tests for the following indicators: - KAMA (Kaufman Adaptive Moving Average) - SMA (Simple Moving Average) - T3 (Tillson T3 Moving Average) - TEMA (Triple Exponential Moving Average) - TRIMA (Triangular Moving Average) - WMA (Weighted Moving Average) - Each test class includes tests for constructor defaults, history depth, short name, initialization, processing updates, and source type handling. - Updated the Quantower.Tests.csproj to include all new test files in the lib directory.
2026-08-22 04:28:04 +00:00 · 2025-12-08 11:40:21 -08:00
parent ed5e5c8209
commit c2b33a8320
15 changed files with 33 additions and 46 deletions
@@ -31,7 +31,7 @@
  </ItemGroup>

  <ItemGroup>
-    <Compile Include="**\*.Tests.cs" />
+    <Compile Include="**\*.Tests.cs" Exclude="**\*.Quantower.Tests.cs" />
  </ItemGroup>

  <ItemGroup>
@@ -0,0 +1,170 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class AlmaIndicatorTests
+{
+    [Fact]
+    public void AlmaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new AlmaIndicator();
+
+        Assert.Equal(9, indicator.Period);
+        Assert.Equal(0.85, indicator.Offset);
+        Assert.Equal(6.0, indicator.Sigma);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("ALMA - Arnaud Legoux Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void AlmaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new AlmaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void AlmaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new AlmaIndicator { Period = 15 };
+
+        Assert.Contains("ALMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void AlmaIndicator_Initialize_CreatesInternalAlma()
+    {
+        var indicator = new AlmaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void AlmaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new AlmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void AlmaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new AlmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        // Process first update
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        // Line series should have values
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void AlmaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new AlmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process historical bar first
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Update with new tick (same bar data - simulates intrabar update)
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Both values should be finite
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void AlmaIndicator_MultipleUpdates_ProducesCorrectAlmaSequence()
+    {
+        var indicator = new AlmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105, 107, 106 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        // ALMA should be smoothing the values
+        double lastAlma = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastAlma >= 100 && lastAlma <= 110);
+    }
+
+    [Fact]
+    public void AlmaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new AlmaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void AlmaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new AlmaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+}
@@ -0,0 +1,179 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class DemaIndicatorTests
+{
+    [Fact]
+    public void DemaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new DemaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("DEMA - Double Exponential Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void DemaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new DemaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void DemaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new DemaIndicator { Period = 15 };
+
+        Assert.Contains("DEMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void DemaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new DemaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink);
+        Assert.Contains("Dema.Quantower.cs", indicator.SourceCodeLink);
+    }
+
+    [Fact]
+    public void DemaIndicator_Initialize_CreatesInternalDema()
+    {
+        var indicator = new DemaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void DemaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new DemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void DemaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new DemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void DemaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new DemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void DemaIndicator_OnPaintChart_DoesNotThrow()
+    {
+        var indicator = new DemaIndicator();
+        indicator.Initialize();
+        
+        // We can't easily mock PaintChartEventArgs fully, but we can verify the method exists and is callable
+        // if we could mock the args. Since we can't, we skip the actual call but verify the method is overridden.
+        var method = indicator.GetType().GetMethod("OnPaintChart");
+        Assert.NotNull(method);
+        Assert.Equal(typeof(DemaIndicator), method.DeclaringType);
+    }
+
+    [Fact]
+    public void DemaIndicator_MultipleUpdates_ProducesCorrectDemaSequence()
+    {
+        var indicator = new DemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+    }
+
+    [Fact]
+    public void DemaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new DemaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void DemaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new DemaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+}
@@ -0,0 +1,169 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class EmaIndicatorTests
+{
+    [Fact]
+    public void EmaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new EmaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("EMA - Exponential Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void EmaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new EmaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void EmaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new EmaIndicator { Period = 15 };
+
+        Assert.Contains("EMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void EmaIndicator_Initialize_CreatesInternalEma()
+    {
+        var indicator = new EmaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void EmaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new EmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void EmaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new EmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        // Process first update
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        // Line series should have values
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void EmaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new EmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process historical bar first
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Update with new tick (same bar data - simulates intrabar update)
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Both values should be finite
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void EmaIndicator_MultipleUpdates_ProducesCorrectEmaSequence()
+    {
+        var indicator = new EmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105, 107, 106 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        // EMA should be smoothing the values
+        // Last EMA value should be between first and last close
+        double lastEma = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastEma >= 100 && lastEma <= 110);
+    }
+
+    [Fact]
+    public void EmaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new EmaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void EmaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new EmaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+}
@@ -0,0 +1,179 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class HmaIndicatorTests
+{
+    [Fact]
+    public void HmaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new HmaIndicator();
+
+        Assert.Equal(14, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("HMA - Hull Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void HmaIndicator_MinHistoryDepths_CalculatedCorrectly()
+    {
+        var indicator = new HmaIndicator { Period = 16 };
+        // HMA warmup is roughly Period + Sqrt(Period)
+        // 16 + Sqrt(16) = 16 + 4 = 20
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void HmaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new HmaIndicator { Period = 21 };
+
+        Assert.Contains("HMA", indicator.ShortName);
+        Assert.Contains("21", indicator.ShortName);
+    }
+
+    [Fact]
+    public void HmaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new HmaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink);
+        Assert.Contains("Hma.cs", indicator.SourceCodeLink);
+    }
+
+    [Fact]
+    public void HmaIndicator_Initialize_CreatesInternalHma()
+    {
+        var indicator = new HmaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void HmaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new HmaIndicator { Period = 4 }; // Small period for easier testing
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void HmaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new HmaIndicator { Period = 4 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void HmaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new HmaIndicator { Period = 4 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void HmaIndicator_OnPaintChart_DoesNotThrow()
+    {
+        var indicator = new HmaIndicator();
+        indicator.Initialize();
+        
+        var method = indicator.GetType().GetMethod("OnPaintChart");
+        Assert.NotNull(method);
+        Assert.Equal(typeof(HmaIndicator), method.DeclaringType);
+    }
+
+    [Fact]
+    public void HmaIndicator_MultipleUpdates_ProducesCorrectHmaSequence()
+    {
+        var indicator = new HmaIndicator { Period = 4 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105, 106, 107 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+    }
+
+    [Fact]
+    public void HmaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new HmaIndicator { Period = 4, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void HmaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new HmaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        // 20 + sqrt(20) = 20 + 4 = 24
+        Assert.Equal(24, indicator.MinHistoryDepths);
+    }
+}
@@ -0,0 +1,170 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class KamaIndicatorTests
+{
+    [Fact]
+    public void KamaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new KamaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(2, indicator.FastPeriod);
+        Assert.Equal(30, indicator.SlowPeriod);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("KAMA - Kaufman Adaptive Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void KamaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new KamaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void KamaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new KamaIndicator { Period = 15 };
+
+        Assert.Contains("KAMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void KamaIndicator_Initialize_CreatesInternalKama()
+    {
+        var indicator = new KamaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void KamaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new KamaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void KamaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new KamaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        // Process first update
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        // Line series should have values
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void KamaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new KamaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process historical bar first
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Update with new tick (same bar data - simulates intrabar update)
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Both values should be finite
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void KamaIndicator_MultipleUpdates_ProducesCorrectKamaSequence()
+    {
+        var indicator = new KamaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105, 107, 106 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        // KAMA should be smoothing the values
+        double lastKama = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastKama >= 100 && lastKama <= 110);
+    }
+
+    [Fact]
+    public void KamaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new KamaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void KamaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new KamaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+}
@@ -69,15 +69,15 @@ public sealed class Kama : ITValuePublisher
        // Buffer needs to hold period + 1 values to calculate Change over 'period' bars
        // Change = Price[0] - Price[period]
        _buffer = new RingBuffer(period + 1);
-        
+
        _fastAlpha = 2.0 / (fastPeriod + 1);
        _slowAlpha = 2.0 / (slowPeriod + 1);
-        
+
        Name = $"Kama({period}, {fastPeriod}, {slowPeriod})";
        _kama = double.NaN;
    }

-    public Kama(ITValuePublisher source, int period = 10, int fastPeriod = 2, int slowPeriod = 30) 
+    public Kama(ITValuePublisher source, int period = 10, int fastPeriod = 2, int slowPeriod = 30)
        : this(period, fastPeriod, slowPeriod)
    {
        source.Pub += (item) => Update(item);
@@ -104,14 +104,11 @@ public sealed class Kama : ITValuePublisher
            _p_kama = _kama;
            _p_volatilitySum = _volatilitySum;

+            bool wasFull = _buffer.IsFull;
            double removed = _buffer.Add(val);

-            if (_buffer.IsFull)
+            if (wasFull)
            {
-                // removed is the value that fell off (Price[period+1] relative to new state?)
-                // No, removed is the value that was at index 0 (oldest).
-                // The new oldest is at index 0.
-                // diff_out was abs(removed - new_oldest).
                double diff_out = Math.Abs(removed - _buffer[0]);
                _lastDiffOut = diff_out;

@@ -153,7 +150,7 @@ public sealed class Kama : ITValuePublisher
        {
            double change = Math.Abs(_buffer[^1] - _buffer[0]);
            double volatility = _volatilitySum;
-            
+
            // Avoid division by zero
            double er = (volatility > double.Epsilon) ? change / volatility : 0.0;
            // Cap ER at 1.0 just in case floating point errors push it slightly over
@@ -177,14 +174,14 @@ public sealed class Kama : ITValuePublisher
        int len = source.Count;
        var t = new List<long>(len);
        var v = new List<double>(len);
-        
+
        // Use static Calculate for performance
        var outputSpan = new double[len];
-        Calculate(source.Values, outputSpan, _period, 
-            (int)(2.0/_fastAlpha - 1), (int)(2.0/_slowAlpha - 1)); // Reverse calc periods from alphas? 
-            // Actually better to pass alphas or periods. 
-            // The static method signature should match constructor params.
-            
+        Calculate(source.Values, outputSpan, _period,
+            (int)(2.0 / _fastAlpha - 1), (int)(2.0 / _slowAlpha - 1)); // Reverse calc periods from alphas? 
+                                                                       // Actually better to pass alphas or periods. 
+                                                                       // The static method signature should match constructor params.
+
        // Wait, I need to pass periods to static method.
        // fastPeriod = 2/fastAlpha - 1.
        int fastPeriod = (int)Math.Round(2.0 / _fastAlpha - 1);
@@ -192,7 +189,7 @@ public sealed class Kama : ITValuePublisher

        Calculate(source.Values, outputSpan, _period, fastPeriod, slowPeriod);

-        for(int i=0; i<len; i++)
+        for (int i = 0; i < len; i++)
        {
            t.Add(source.Times[i]);
            v.Add(outputSpan[i]);
@@ -217,14 +214,14 @@ public sealed class Kama : ITValuePublisher

        double fastAlpha = 2.0 / (fastPeriod + 1);
        double slowAlpha = 2.0 / (slowPeriod + 1);
-        
+
        // We need a buffer for price history to calculate ER
        // Size period + 1
        int bufSize = period + 1;
        Span<double> buffer = bufSize <= 256 ? stackalloc double[bufSize] : new double[bufSize];
        int bufferIdx = 0;
        int count = 0;
-        
+
        double volatilitySum = 0;
        double kama = 0;
        bool kamaInitialized = false;
@@ -241,7 +238,7 @@ public sealed class Kama : ITValuePublisher
            // Add to buffer
            double removed = buffer[bufferIdx];
            buffer[bufferIdx] = val;
-            
+
            // Update volatility
            if (count >= 1)
            {
@@ -249,9 +246,9 @@ public sealed class Kama : ITValuePublisher
                // prev is at bufferIdx-1 (circular)
                int prevIdx = (bufferIdx - 1 + bufSize) % bufSize;
                double diff_in = Math.Abs(val - buffer[prevIdx]);
-                
+
                volatilitySum += diff_in;
-                
+
                if (count == bufSize)
                {
                    // diff_out = abs(removed - new_oldest)
@@ -281,31 +278,18 @@ public sealed class Kama : ITValuePublisher
                // Wait, bufferIdx points to where we WILL write next.
                // So buffer[bufferIdx] is the oldest value (the one that will be overwritten next).
                // So Change = abs(val - buffer[bufferIdx])
-                
+
                double change = 0;
-                if (count == bufSize)
-                {
-                    change = Math.Abs(val - buffer[bufferIdx]);
-                }
-                else
-                {
-                    // If not full, oldest is at 0?
-                    // No, we fill 0, 1, 2...
-                    // Oldest is at 0.
-                    // But bufferIdx wraps.
-                    // If count < bufSize, we haven't wrapped yet (except maybe once if count==bufSize?)
-                    // If count < bufSize, bufferIdx is the index of next write.
-                    // Oldest is at 0.
-                    change = Math.Abs(val - buffer[0]);
-                }
+                change = (count == bufSize) ? Math.Abs(val - buffer[bufferIdx]) : Math.Abs(val - buffer[0]);
+

                double er = (volatilitySum > double.Epsilon) ? change / volatilitySum : 0.0;
                if (er > 1.0) er = 1.0;

                double sc = er * (fastAlpha - slowAlpha) + slowAlpha;
-                sc = sc * sc;
+                sc *= sc;

-                kama = kama + sc * (val - kama);
+                kama += sc * (val - kama);
                output[i] = kama;
            }
        }
@@ -320,5 +304,6 @@ public sealed class Kama : ITValuePublisher
        _p_volatilitySum = 0;
        _lastDiffOut = 0;
        _lastValidValue = 0;
+        Last = default;
    }
 }
@@ -0,0 +1,182 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class SmaIndicatorTests
+{
+    [Fact]
+    public void SmaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new SmaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("SMA - Simple Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void SmaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new SmaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void SmaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new SmaIndicator { Period = 15 };
+
+        Assert.Contains("SMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void SmaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new SmaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink);
+        Assert.Contains("Sma.Quantower.cs", indicator.SourceCodeLink);
+    }
+
+    [Fact]
+    public void SmaIndicator_Initialize_CreatesInternalSma()
+    {
+        var indicator = new SmaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void SmaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new SmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void SmaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new SmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void SmaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new SmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void SmaIndicator_OnPaintChart_DoesNotThrow()
+    {
+        var indicator = new SmaIndicator();
+        indicator.Initialize();
+        
+        var method = indicator.GetType().GetMethod("OnPaintChart");
+        Assert.NotNull(method);
+        Assert.Equal(typeof(SmaIndicator), method.DeclaringType);
+    }
+
+    [Fact]
+    public void SmaIndicator_MultipleUpdates_ProducesCorrectSmaSequence()
+    {
+        var indicator = new SmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        // Last SMA(3) should be average of last 3 values: (103 + 105 + 104) / 3 ≈ 104
+        // Actually: (104 + 103 + 105) / 3 = 104
+        double lastSma = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastSma >= 103 && lastSma <= 105);
+    }
+
+    [Fact]
+    public void SmaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new SmaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void SmaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new SmaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+}
@@ -0,0 +1,173 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class T3IndicatorTests
+{
+    [Fact]
+    public void T3Indicator_Constructor_SetsDefaults()
+    {
+        var indicator = new T3Indicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(0.7, indicator.VolumeFactor);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("T3 - Tillson T3 Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void T3Indicator_MinHistoryDepths_EqualsSixTimesPeriod()
+    {
+        var indicator = new T3Indicator { Period = 10 };
+
+        // MinHistoryDepths is Period * 6 for T3 due to 6 stages
+        Assert.Equal(60, indicator.MinHistoryDepths);
+        Assert.Equal(60, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void T3Indicator_ShortName_IncludesPeriodAndFactor()
+    {
+        var indicator = new T3Indicator { Period = 15, VolumeFactor = 0.618 };
+
+        Assert.Contains("T3", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+        Assert.Contains("0.62", indicator.ShortName); // F2 formatting
+    }
+
+    [Fact]
+    public void T3Indicator_Initialize_CreatesInternalT3()
+    {
+        var indicator = new T3Indicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void T3Indicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new T3Indicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void T3Indicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new T3Indicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        // Process first update
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        // Line series should have values
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void T3Indicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new T3Indicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process historical bar first
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Update with new tick (same bar data - simulates intrabar update)
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        // Both values should be finite
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void T3Indicator_MultipleUpdates_ProducesCorrectT3Sequence()
+    {
+        var indicator = new T3Indicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105, 107, 106 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        double lastT3 = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastT3 >= 100 && lastT3 <= 110);
+    }
+
+    [Fact]
+    public void T3Indicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new T3Indicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void T3Indicator_Parameters_CanBeChanged()
+    {
+        var indicator = new T3Indicator { Period = 5, VolumeFactor = 0.5 };
+        Assert.Equal(5, indicator.Period);
+        Assert.Equal(0.5, indicator.VolumeFactor);
+
+        indicator.Period = 20;
+        indicator.VolumeFactor = 0.9;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(0.9, indicator.VolumeFactor);
+        Assert.Equal(120, indicator.MinHistoryDepths); // 20 * 6
+    }
+}
@@ -0,0 +1,177 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class TemaIndicatorTests
+{
+    [Fact]
+    public void TemaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new TemaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("TEMA - Triple Exponential Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void TemaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new TemaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void TemaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new TemaIndicator { Period = 15 };
+
+        Assert.Contains("TEMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void TemaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new TemaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink);
+        Assert.Contains("Tema.Quantower.cs", indicator.SourceCodeLink);
+    }
+
+    [Fact]
+    public void TemaIndicator_Initialize_CreatesInternalTema()
+    {
+        var indicator = new TemaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void TemaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new TemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void TemaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new TemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void TemaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new TemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void TemaIndicator_OnPaintChart_DoesNotThrow()
+    {
+        var indicator = new TemaIndicator();
+        indicator.Initialize();
+        
+        var method = indicator.GetType().GetMethod("OnPaintChart");
+        Assert.NotNull(method);
+        Assert.Equal(typeof(TemaIndicator), method.DeclaringType);
+    }
+
+    [Fact]
+    public void TemaIndicator_MultipleUpdates_ProducesCorrectTemaSequence()
+    {
+        var indicator = new TemaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+    }
+
+    [Fact]
+    public void TemaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new TemaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void TemaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new TemaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+}
@@ -0,0 +1,189 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class TrimaIndicatorTests
+{
+    [Fact]
+    public void TrimaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new TrimaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("TRIMA - Triangular Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void TrimaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new TrimaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void TrimaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new TrimaIndicator { Period = 15 };
+
+        Assert.Contains("TRIMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void TrimaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new TrimaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink);
+        Assert.Contains("Trima.Quantower.cs", indicator.SourceCodeLink);
+    }
+
+    [Fact]
+    public void TrimaIndicator_Initialize_CreatesInternalTrima()
+    {
+        var indicator = new TrimaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void TrimaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new TrimaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void TrimaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new TrimaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void TrimaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new TrimaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void TrimaIndicator_OnPaintChart_DoesNotThrow()
+    {
+        var indicator = new TrimaIndicator();
+        indicator.Initialize();
+        
+        var method = indicator.GetType().GetMethod("OnPaintChart");
+        Assert.NotNull(method);
+        Assert.Equal(typeof(TrimaIndicator), method.DeclaringType);
+    }
+
+    [Fact]
+    public void TrimaIndicator_MultipleUpdates_ProducesCorrectTrimaSequence()
+    {
+        var indicator = new TrimaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        // TRIMA is smoothed, so check last value is reasonable
+        double lastTrima = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastTrima >= 100 && lastTrima <= 106);
+    }
+
+    [Fact]
+    public void TrimaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new TrimaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void TrimaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new TrimaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void TrimaIndicator_DescriptionIsSet()
+    {
+        var indicator = new TrimaIndicator();
+
+        Assert.Contains("Triangular", indicator.Description);
+    }
+}
@@ -0,0 +1,190 @@
+using Xunit;
+using TradingPlatform.BusinessLayer;
+
+namespace QuanTAlib.Tests;
+
+public class WmaIndicatorTests
+{
+    [Fact]
+    public void WmaIndicator_Constructor_SetsDefaults()
+    {
+        var indicator = new WmaIndicator();
+
+        Assert.Equal(10, indicator.Period);
+        Assert.Equal(SourceType.Close, indicator.Source);
+        Assert.True(indicator.ShowColdValues);
+        Assert.Equal("WMA - Weighted Moving Average", indicator.Name);
+        Assert.False(indicator.SeparateWindow);
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void WmaIndicator_MinHistoryDepths_EqualsPeriod()
+    {
+        var indicator = new WmaIndicator { Period = 20 };
+
+        Assert.Equal(20, indicator.MinHistoryDepths);
+        Assert.Equal(20, ((IWatchlistIndicator)indicator).MinHistoryDepths);
+    }
+
+    [Fact]
+    public void WmaIndicator_ShortName_IncludesPeriodAndSource()
+    {
+        var indicator = new WmaIndicator { Period = 15 };
+
+        Assert.Contains("WMA", indicator.ShortName);
+        Assert.Contains("15", indicator.ShortName);
+    }
+
+    [Fact]
+    public void WmaIndicator_SourceCodeLink_IsValid()
+    {
+        var indicator = new WmaIndicator();
+
+        Assert.Contains("github.com", indicator.SourceCodeLink);
+        Assert.Contains("Wma.Quantower.cs", indicator.SourceCodeLink);
+    }
+
+    [Fact]
+    public void WmaIndicator_Initialize_CreatesInternalWma()
+    {
+        var indicator = new WmaIndicator { Period = 10 };
+
+        // Initialize should not throw
+        indicator.Initialize();
+
+        // After init, line series should exist
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void WmaIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new WmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        // Add historical data
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        // Process update
+        var args = new UpdateArgs(UpdateReason.HistoricalBar);
+        indicator.ProcessUpdate(args);
+
+        // Line series should have a value
+        Assert.Equal(1, indicator.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
+    }
+
+    [Fact]
+    public void WmaIndicator_ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new WmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 102, 108, 100, 106);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, indicator.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void WmaIndicator_ProcessUpdate_NewTick_ProcessesWithoutError()
+    {
+        var indicator = new WmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        indicator.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        double firstValue = indicator.LinesSeries[0].GetValue(0);
+
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+        double secondValue = indicator.LinesSeries[0].GetValue(0);
+
+        Assert.True(double.IsFinite(firstValue));
+        Assert.True(double.IsFinite(secondValue));
+    }
+
+    [Fact]
+    public void WmaIndicator_OnPaintChart_DoesNotThrow()
+    {
+        var indicator = new WmaIndicator();
+        indicator.Initialize();
+        
+        var method = indicator.GetType().GetMethod("OnPaintChart");
+        Assert.NotNull(method);
+        Assert.Equal(typeof(WmaIndicator), method.DeclaringType);
+    }
+
+    [Fact]
+    public void WmaIndicator_MultipleUpdates_ProducesCorrectWmaSequence()
+    {
+        var indicator = new WmaIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        double[] closes = { 100, 102, 104, 103, 105 };
+
+        foreach (var close in closes)
+        {
+            indicator.HistoricalData.AddBar(now, close, close + 2, close - 2, close);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+            now = now.AddMinutes(1);
+        }
+
+        // All values should be finite
+        for (int i = 0; i < closes.Length; i++)
+        {
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(closes.Length - 1 - i)));
+        }
+
+        // WMA gives more weight to recent values
+        // With weights [1, 2, 3] for period 3: (104*1 + 103*2 + 105*3) / 6 = 625/6 ≈ 104.17
+        double lastWma = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(lastWma >= 103 && lastWma <= 106);
+    }
+
+    [Fact]
+    public void WmaIndicator_DifferentSourceTypes_Work()
+    {
+        var sources = new[] { SourceType.Open, SourceType.High, SourceType.Low, SourceType.Close, SourceType.HL2, SourceType.HLC3 };
+
+        foreach (var source in sources)
+        {
+            var indicator = new WmaIndicator { Period = 3, Source = source };
+            indicator.Initialize();
+
+            var now = DateTime.UtcNow;
+            indicator.HistoricalData.AddBar(now, 100, 110, 90, 105);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+            Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)),
+                $"Source {source} should produce finite value");
+        }
+    }
+
+    [Fact]
+    public void WmaIndicator_Period_CanBeChanged()
+    {
+        var indicator = new WmaIndicator { Period = 5 };
+        Assert.Equal(5, indicator.Period);
+
+        indicator.Period = 20;
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(20, indicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void WmaIndicator_DescriptionIsSet()
+    {
+        var indicator = new WmaIndicator();
+
+        Assert.Contains("Weighted", indicator.Description);
+    }
+}