docs: remove C# Implementation Considerations sections, clean up temp scripts, reorganize test files

- Remove 'C# Implementation Considerations' sections from 34 indicator .md files - Delete 29 temp PowerShell scripts (_fix_mojibake.ps1, _hex_scan.ps1, etc.) - Move test files into tests/ subdirectories for consistent project structure - Add trader-focused bullet points to indicator documentation
2026-08-23 21:18:04 +00:00 · 2026-03-12 12:34:16 -07:00
parent 8937b0c0fa
commit 060649192f
1149 changed files with 1780 additions and 3316 deletions
@@ -0,0 +1,333 @@
+using TradingPlatform.BusinessLayer;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class TtmTrendIndicatorTests
+{
+    [Fact]
+    public void Constructor_CreatesValidIndicator()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.NotNull(indicator);
+        Assert.Equal("TTM Trend", indicator.Name);
+    }
+
+    [Fact]
+    public void Constructor_SetsDescription()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.Contains("TTM Trend", indicator.Description, StringComparison.Ordinal);
+        Assert.Contains("EMA", indicator.Description, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DefaultPeriod_Is6()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.Equal(6, indicator.Period);
+    }
+
+    [Fact]
+    public void DefaultShowColdValues_IsTrue()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.True(indicator.ShowColdValues);
+    }
+
+    [Fact]
+    public void ShortName_IncludesParameters()
+    {
+        var indicator = new TtmTrendIndicator { Period = 10 };
+        Assert.Equal("TTM_TREND(10)", indicator.ShortName);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsZero()
+    {
+        var indicator = new TtmTrendIndicator { Period = 10 };
+        Assert.Equal(0, TtmTrendIndicator.MinHistoryDepths);
+        IWatchlistIndicator watchlistIndicator = indicator;
+        Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void SeparateWindow_IsFalse()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.False(indicator.SeparateWindow);
+    }
+
+    [Fact]
+    public void OnBackGround_IsTrue()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.True(indicator.OnBackGround);
+    }
+
+    [Fact]
+    public void Constructor_AddsOneLineSeries()
+    {
+        var indicator = new TtmTrendIndicator();
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void Parameters_CanBeChanged()
+    {
+        var indicator = new TtmTrendIndicator { Period = 6 };
+
+        indicator.Period = 20;
+
+        Assert.Equal(20, indicator.Period);
+        Assert.Equal(0, TtmTrendIndicator.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ShowColdValues_CanBeChanged()
+    {
+        var indicator = new TtmTrendIndicator();
+
+        indicator.ShowColdValues = false;
+
+        Assert.False(indicator.ShowColdValues);
+    }
+
+    [Fact]
+    public void Initialize_CreatesInternalIndicator()
+    {
+        var indicator = new TtmTrendIndicator { Period = 10 };
+
+        indicator.Initialize();
+
+        // Line series count should remain 1 after init
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void ProcessUpdate_HistoricalBar_ComputesValue()
+    {
+        var indicator = new TtmTrendIndicator { Period = 6 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewBar_ComputesValue()
+    {
+        var indicator = new TtmTrendIndicator { Period = 6 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i);
+            var args = new UpdateArgs(UpdateReason.HistoricalBar);
+            indicator.ProcessUpdate(args);
+        }
+
+        // Simulate a new bar
+        indicator.HistoricalData.AddBar(now.AddMinutes(10), 110, 120, 100, 115);
+        var newArgs = new UpdateArgs(UpdateReason.NewBar);
+        indicator.ProcessUpdate(newArgs);
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void ProcessUpdate_BullishTrend_ProducesGreenMarker()
+    {
+        var indicator = new TtmTrendIndicator { Period = 2 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Feed strongly rising bars to trigger bullish trend (Trend == 1)
+        indicator.HistoricalData.AddBar(now, 50.0, 55.0, 48.0, 52.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 60.0, 65.0, 58.0, 62.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(2), 70.0, 75.0, 68.0, 72.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(3), 80.0, 85.0, 78.0, 82.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // Value should be finite after enough bars
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void ProcessUpdate_BearishTrend_ProducesRedMarker()
+    {
+        var indicator = new TtmTrendIndicator { Period = 2 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Feed strongly falling bars to trigger bearish trend (Trend == -1)
+        indicator.HistoricalData.AddBar(now, 100.0, 105.0, 98.0, 102.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(1), 90.0, 95.0, 88.0, 92.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(2), 80.0, 85.0, 78.0, 82.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        indicator.HistoricalData.AddBar(now.AddMinutes(3), 70.0, 75.0, 68.0, 72.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void ProcessUpdate_FlatPrices_ProducesGrayMarker()
+    {
+        var indicator = new TtmTrendIndicator { Period = 2 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Feed identical bars to get Trend == 0 (neutral)
+        for (int i = 0; i < 5; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 100.0, 100.0, 100.0);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void ProcessUpdate_ColdValues_HiddenWhenDisabled()
+    {
+        var indicator = new TtmTrendIndicator { Period = 6, ShowColdValues = false };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Only 1 bar — indicator should not yet be hot
+        indicator.HistoricalData.AddBar(now, 100.0, 105.0, 98.0, 102.0);
+        indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        // With ShowColdValues=false, the cold value should not be set
+        // (LineSeries.SetValue with isHot=false and showCold=false skips the value)
+        Assert.Single(indicator.LinesSeries);
+    }
+
+    [Fact]
+    public void CalculationIntegration_ProducesCorrectValues()
+    {
+        var ttmCore = new TtmTrend(6);
+        var time = DateTime.UtcNow;
+
+        var bar1 = new TBar(time.Ticks, 100.0, 105.0, 98.0, 102.0, 1000);
+        var bar2 = new TBar(time.AddMinutes(1).Ticks, 102.0, 108.0, 100.0, 106.0, 1000);
+
+        ttmCore.Update(bar1);
+        var result = ttmCore.Update(bar2);
+
+        // After 2 bars, should be hot and have valid value
+        Assert.True(ttmCore.IsHot);
+        Assert.True(double.IsFinite(result.Value));
+    }
+
+    [Fact]
+    public void TrendDirection_Bullish_WhenRising()
+    {
+        var ttmCore = new TtmTrend(6);
+        var time = DateTime.UtcNow;
+
+        ttmCore.Update(new TBar(time.Ticks, 100.0, 105.0, 98.0, 102.0, 1000));
+        ttmCore.Update(new TBar(time.AddMinutes(1).Ticks, 110.0, 115.0, 108.0, 112.0, 1000));
+
+        Assert.Equal(1, ttmCore.Trend);
+    }
+
+    [Fact]
+    public void TrendDirection_Bearish_WhenFalling()
+    {
+        var ttmCore = new TtmTrend(6);
+        var time = DateTime.UtcNow;
+
+        ttmCore.Update(new TBar(time.Ticks, 100.0, 105.0, 98.0, 102.0, 1000));
+        ttmCore.Update(new TBar(time.AddMinutes(1).Ticks, 90.0, 95.0, 88.0, 92.0, 1000));
+
+        Assert.Equal(-1, ttmCore.Trend);
+    }
+
+    [Fact]
+    public void CoreIndicator_ResetsCorrectly()
+    {
+        var ttm = new TtmTrend(6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TBar(time.Ticks, 100.0, 105.0, 98.0, 102.0, 1000));
+        ttm.Update(new TBar(time.AddMinutes(1).Ticks, 102.0, 108.0, 100.0, 106.0, 1000));
+
+        Assert.True(ttm.IsHot);
+
+        ttm.Reset();
+
+        Assert.False(ttm.IsHot);
+        Assert.Equal(default, ttm.Last);
+        Assert.Equal(0, ttm.Trend);
+    }
+
+    [Fact]
+    public void ProcessUpdate_MultipleNewBars_AccumulatesValues()
+    {
+        var indicator = new TtmTrendIndicator { Period = 3 };
+        indicator.Initialize();
+
+        var now = DateTime.UtcNow;
+
+        // Feed historical bars
+        for (int i = 0; i < 5; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i * 2, 110 + i * 2, 90 + i * 2, 105 + i * 2);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        }
+
+        // Feed new bars
+        for (int i = 5; i < 8; i++)
+        {
+            indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i * 2, 110 + i * 2, 90 + i * 2, 105 + i * 2);
+            indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+        }
+
+        double value = indicator.LinesSeries[0].GetValue(0);
+        Assert.True(double.IsFinite(value));
+    }
+
+    [Fact]
+    public void Initialize_AfterParameterChange_UsesNewPeriod()
+    {
+        var indicator = new TtmTrendIndicator { Period = 6 };
+        indicator.Initialize();
+
+        // Change period and re-initialize
+        indicator.Period = 20;
+        indicator.Initialize();
+
+        Assert.Equal("TTM_TREND(20)", indicator.ShortName);
+    }
+}
@@ -0,0 +1,469 @@
+// TTM_TREND Tests - John Carter's TTM Trend Indicator
+
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Constructor Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendConstructorTests
+{
+    [Fact]
+    public void Constructor_DefaultPeriod_Is6()
+    {
+        var ttm = new TtmTrend();
+        Assert.Equal(6, ttm.Period);
+    }
+
+    [Fact]
+    public void Constructor_CustomPeriod_IsSet()
+    {
+        var ttm = new TtmTrend(period: 10);
+        Assert.Equal(10, ttm.Period);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-1)]
+    [InlineData(-10)]
+    public void Constructor_InvalidPeriod_Throws(int period)
+    {
+        Assert.Throws<ArgumentException>(() => new TtmTrend(period));
+    }
+
+    [Fact]
+    public void Constructor_MinPeriod_IsValid()
+    {
+        var ttm = new TtmTrend(period: 1);
+        Assert.Equal(1, ttm.Period);
+    }
+
+    [Fact]
+    public void Name_ContainsPeriod()
+    {
+        var ttm = new TtmTrend(period: 10);
+        Assert.Contains("10", ttm.Name, StringComparison.Ordinal);
+        Assert.Contains("TTM_TREND", ttm.Name, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void WarmupPeriod_Is2()
+    {
+        Assert.Equal(2, TtmTrend.WarmupPeriod);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Basic Operation Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendBasicTests
+{
+    [Fact]
+    public void Update_FirstBar_ReturnsValue()
+    {
+        var ttm = new TtmTrend();
+        var result = ttm.Update(new TValue(DateTime.UtcNow.Ticks, 100.0));
+        Assert.Equal(100.0, result.Value);
+    }
+
+    [Fact]
+    public void Update_SecondBar_CalculatesEma()
+    {
+        var ttm = new TtmTrend(period: 6);  // alpha = 2/7 ≈ 0.2857
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        var result = ttm.Update(new TValue(time.AddMinutes(1).Ticks, 107.0));
+
+        // EMA = alpha * value + (1 - alpha) * prevEMA
+        // EMA = 0.2857 * 107 + 0.7143 * 100 = 30.57 + 71.43 = 102.0
+        double alpha = 2.0 / 7.0;
+        double expected = alpha * 107.0 + (1 - alpha) * 100.0;
+        Assert.Equal(expected, result.Value, 10);
+    }
+
+    [Fact]
+    public void IsHot_AfterFirstBar_IsFalse()
+    {
+        var ttm = new TtmTrend();
+        ttm.Update(new TValue(DateTime.UtcNow.Ticks, 100.0));
+        Assert.False(ttm.IsHot);
+    }
+
+    [Fact]
+    public void IsHot_AfterSecondBar_IsTrue()
+    {
+        var ttm = new TtmTrend();
+        var time = DateTime.UtcNow;
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 101.0));
+        Assert.True(ttm.IsHot);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Trend Direction Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendDirectionTests
+{
+    [Fact]
+    public void Trend_RisingValues_IsBullish()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 110.0));
+
+        Assert.Equal(1, ttm.Trend);
+    }
+
+    [Fact]
+    public void Trend_FallingValues_IsBearish()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 90.0));
+
+        Assert.Equal(-1, ttm.Trend);
+    }
+
+    [Fact]
+    public void Trend_SameValue_IsNeutral()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 100.0));
+
+        Assert.Equal(0, ttm.Trend);
+    }
+
+    [Fact]
+    public void Trend_CanChangeDirection()
+    {
+        var ttm = new TtmTrend(period: 2);  // Fast EMA
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 110.0));
+        Assert.Equal(1, ttm.Trend);
+
+        // Drop significantly to reverse trend
+        ttm.Update(new TValue(time.AddMinutes(2).Ticks, 90.0));
+        Assert.Equal(-1, ttm.Trend);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Strength Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendStrengthTests
+{
+    [Fact]
+    public void Strength_IsPositive()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 110.0));
+
+        Assert.True(ttm.Strength > 0);
+    }
+
+    [Fact]
+    public void Strength_ZeroOnFirstBar()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+
+        Assert.Equal(0, ttm.Strength);
+    }
+
+    [Fact]
+    public void Strength_LargerMoves_HigherStrength()
+    {
+        var ttm1 = new TtmTrend(period: 6);
+        var ttm2 = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        // Small move
+        ttm1.Update(new TValue(time.Ticks, 100.0));
+        ttm1.Update(new TValue(time.AddMinutes(1).Ticks, 101.0));
+
+        // Large move
+        ttm2.Update(new TValue(time.Ticks, 100.0));
+        ttm2.Update(new TValue(time.AddMinutes(1).Ticks, 110.0));
+
+        Assert.True(ttm2.Strength > ttm1.Strength);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Bar Input Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendBarInputTests
+{
+    [Fact]
+    public void Update_Bar_UsesTypicalPrice()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var bar = new TBar(DateTime.UtcNow.Ticks, 100.0, 105.0, 98.0, 102.0, 1000);
+
+        var result = ttm.Update(bar);
+
+        // Typical price = (H + L + C) / 3 = (105 + 98 + 102) / 3 = 101.67
+        double typical = (105.0 + 98.0 + 102.0) / 3.0;
+        Assert.Equal(typical, result.Value, 10);
+    }
+
+    [Fact]
+    public void Update_BarSeries_ReturnsCorrectLength()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            bars.Add(new TBar(time.AddMinutes(i).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
+        }
+
+        var result = ttm.Update(bars);
+        Assert.Equal(10, result.Count);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Edge Case Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendEdgeCaseTests
+{
+    [Fact]
+    public void Update_NaN_ReturnsLastValue()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        var result1 = ttm.Update(new TValue(time.Ticks, 100.0));
+        var result2 = ttm.Update(new TValue(time.AddMinutes(1).Ticks, double.NaN));
+
+        Assert.Equal(result1.Value, result2.Value);
+    }
+
+    [Fact]
+    public void Update_Infinity_ReturnsLastValue()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        var result1 = ttm.Update(new TValue(time.Ticks, 100.0));
+        var result2 = ttm.Update(new TValue(time.AddMinutes(1).Ticks, double.PositiveInfinity));
+
+        Assert.Equal(result1.Value, result2.Value);
+    }
+
+    [Fact]
+    public void Update_LargeValues_CalculatesCorrectly()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        var result = ttm.Update(new TValue(time.Ticks, 1e10));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.Equal(1e10, result.Value);
+    }
+
+    [Fact]
+    public void Update_SmallValues_CalculatesCorrectly()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        var result = ttm.Update(new TValue(time.Ticks, 1e-10));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.Equal(1e-10, result.Value);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Reset Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendResetTests
+{
+    [Fact]
+    public void Reset_ClearsState()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 110.0));
+
+        Assert.True(ttm.IsHot);
+
+        ttm.Reset();
+
+        Assert.False(ttm.IsHot);
+        Assert.Equal(default, ttm.Last);
+        Assert.Equal(0, ttm.Trend);
+        Assert.Equal(0, ttm.Strength);
+    }
+
+    [Fact]
+    public void Reset_CanReuseAfterReset()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 110.0));
+        ttm.Reset();
+
+        var result = ttm.Update(new TValue(time.AddMinutes(2).Ticks, 200.0));
+
+        Assert.Equal(200.0, result.Value);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Bar Correction Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendBarCorrectionTests
+{
+    [Fact]
+    public void Update_IsNewFalse_CorrectsPreviousValue()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var time = DateTime.UtcNow;
+
+        ttm.Update(new TValue(time.Ticks, 100.0));
+        ttm.Update(new TValue(time.AddMinutes(1).Ticks, 110.0), isNew: true);
+
+        // Correct the bar with different value
+        var corrected = ttm.Update(new TValue(time.AddMinutes(1).Ticks, 105.0), isNew: false);
+
+        // Should use 105 instead of 110
+        double alpha = 2.0 / 7.0;
+        double expected = alpha * 105.0 + (1 - alpha) * 100.0;
+        Assert.Equal(expected, corrected.Value, 10);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Batch Processing Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendBatchTests
+{
+    [Fact]
+    public void Batch_ReturnsCorrectResults()
+    {
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            bars.Add(new TBar(time.AddMinutes(i).Ticks, 100.0 + i, 105.0 + i, 95.0 + i, 102.0 + i, 1000));
+        }
+
+        var result = TtmTrend.Batch(bars, period: 6);
+
+        Assert.Equal(10, result.Count);
+    }
+
+    [Fact]
+    public void Calculate_ReturnsIndicatorAndResults()
+    {
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            bars.Add(new TBar(time.AddMinutes(i).Ticks, 100.0 + i, 105.0 + i, 95.0 + i, 102.0 + i, 1000));
+        }
+
+        var (results, indicator) = TtmTrend.Calculate(bars, period: 6);
+
+        Assert.Equal(10, results.Count);
+        Assert.True(indicator.IsHot);
+        Assert.Equal(6, indicator.Period);
+    }
+
+    [Fact]
+    public void Update_EmptyBarSeries_ReturnsEmpty()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var bars = new TBarSeries();
+
+        var result = ttm.Update(bars);
+
+        Assert.True(result.Count == 0);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Event Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendEventTests
+{
+    [Fact]
+    public void Update_RaisesPubEvent()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var eventRaised = false;
+        TValue receivedValue = default;
+
+        ttm.Pub += (object? sender, in TValueEventArgs args) =>
+        {
+            eventRaised = true;
+            receivedValue = args.Value;
+        };
+
+        var result = ttm.Update(new TValue(DateTime.UtcNow.Ticks, 100.0));
+
+        Assert.True(eventRaised);
+        Assert.Equal(result.Value, receivedValue.Value);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Prime Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+public class TtmTrendPrimeTests
+{
+    [Fact]
+    public void Prime_WarmUpIndicator()
+    {
+        var ttm = new TtmTrend(period: 6);
+        var bars = new TBarSeries();
+        var time = DateTime.UtcNow;
+
+        for (int i = 0; i < 10; i++)
+        {
+            bars.Add(new TBar(time.AddMinutes(i).Ticks, 100.0 + i, 105.0 + i, 95.0 + i, 102.0 + i, 1000));
+        }
+
+        ttm.Prime(bars);
+
+        Assert.True(ttm.IsHot);
+        Assert.NotEqual(default, ttm.Last);
+    }
+}
@@ -0,0 +1,229 @@
+// TtmTrend: Mathematical property validation tests
+// TTM Trend is a proprietary John Carter indicator — no external library equivalents exist.
+// Validation uses mathematical property testing against known EMA behaviors.
+
+namespace QuanTAlib.Tests;
+
+using Xunit;
+
+public class TtmTrendValidationTests
+{
+    private const int DefaultPeriod = 6;
+    private const int TestDataLength = 500;
+
+    [Fact]
+    public void TtmTrend_EmaOutput_IsFiniteForGbmData()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var ttm = new TtmTrend(DefaultPeriod);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            var result = ttm.Update(bars[i], isNew: true);
+            Assert.True(double.IsFinite(result.Value),
+                $"TtmTrend output must be finite at bar {i}, got {result.Value}");
+        }
+    }
+
+    [Fact]
+    public void TtmTrend_TrendDirection_OnlyValidValues()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var ttm = new TtmTrend(DefaultPeriod);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ttm.Update(bars[i], isNew: true);
+
+            Assert.True(ttm.Trend is -1 or 0 or 1,
+                $"Trend must be -1, 0, or 1 at bar {i}, got {ttm.Trend}");
+        }
+    }
+
+    [Fact]
+    public void TtmTrend_Strength_IsNonNegative()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var ttm = new TtmTrend(DefaultPeriod);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ttm.Update(bars[i], isNew: true);
+
+            Assert.True(ttm.Strength >= 0,
+                $"Strength must be >= 0 at bar {i}, got {ttm.Strength}");
+        }
+    }
+
+    [Fact]
+    public void TtmTrend_RisingSequence_BullishTrend()
+    {
+        var ttm = new TtmTrend(DefaultPeriod);
+        double basePrice = 100.0;
+
+        // Feed enough bars to warm up, then inject consistently rising prices
+        for (int i = 0; i < 20; i++)
+        {
+            double price = basePrice + i * 2.0;
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                price - 0.5, price + 0.5, price - 0.5, price, 1000);
+            ttm.Update(bar, isNew: true);
+        }
+
+        // After a consistently rising sequence, trend should be bullish
+        Assert.Equal(1, ttm.Trend);
+    }
+
+    [Fact]
+    public void TtmTrend_FallingSequence_BearishTrend()
+    {
+        var ttm = new TtmTrend(DefaultPeriod);
+        double basePrice = 200.0;
+
+        // Feed enough bars to warm up, then inject consistently falling prices
+        for (int i = 0; i < 20; i++)
+        {
+            double price = basePrice - i * 2.0;
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                price + 0.5, price + 0.5, price - 0.5, price, 1000);
+            ttm.Update(bar, isNew: true);
+        }
+
+        // After a consistently falling sequence, trend should be bearish
+        Assert.Equal(-1, ttm.Trend);
+    }
+
+    [Fact]
+    public void TtmTrend_ConstantPrice_ZeroStrength()
+    {
+        var ttm = new TtmTrend(DefaultPeriod);
+        double price = 100.0;
+
+        // Feed constant-price bars
+        for (int i = 0; i < 20; i++)
+        {
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                price, price, price, price, 1000);
+            ttm.Update(bar, isNew: true);
+        }
+
+        // Strength should be 0 for a constant series (no percent change)
+        Assert.Equal(0.0, ttm.Strength, precision: 10);
+    }
+
+    [Fact]
+    public void TtmTrend_EmaConvergesToConstant()
+    {
+        var ttm = new TtmTrend(DefaultPeriod);
+        double targetPrice = 100.0;
+
+        // Start at 50, abruptly switch to constant 100
+        for (int i = 0; i < 5; i++)
+        {
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                50, 50, 50, 50, 1000);
+            ttm.Update(bar, isNew: true);
+        }
+
+        // Now feed constant 100 for many bars
+        for (int i = 5; i < 100; i++)
+        {
+            var bar = new TBar(
+                DateTime.UtcNow.AddMinutes(i),
+                targetPrice, targetPrice, targetPrice, targetPrice, 1000);
+            ttm.Update(bar, isNew: true);
+        }
+
+        // EMA output should converge to the target price
+        Assert.Equal(targetPrice, ttm.Last.Value, precision: 6);
+    }
+
+    [Fact]
+    public void TtmTrend_BatchAndStreaming_ProduceSameResults()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(TestDataLength, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        // Batch mode
+        var batchResults = TtmTrend.Batch(bars, DefaultPeriod);
+
+        // Streaming mode
+        var streamTtm = new TtmTrend(DefaultPeriod);
+        var streamResults = new double[bars.Count];
+        for (int i = 0; i < bars.Count; i++)
+        {
+            var result = streamTtm.Update(bars[i], isNew: true);
+            streamResults[i] = result.Value;
+        }
+
+        // Both must match
+        Assert.Equal(batchResults.Count, bars.Count);
+        for (int i = 0; i < bars.Count; i++)
+        {
+            Assert.Equal(batchResults.Values[i], streamResults[i], precision: 10);
+        }
+    }
+
+    [Fact]
+    public void TtmTrend_DifferentPeriods_ProduceDifferentEmaSmoothing()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(100, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+
+        var ttm3 = new TtmTrend(period: 3);
+        var ttm20 = new TtmTrend(period: 20);
+
+        for (int i = 0; i < bars.Count; i++)
+        {
+            ttm3.Update(bars[i], isNew: true);
+            ttm20.Update(bars[i], isNew: true);
+        }
+
+        // Different periods should produce different final values (except on trivially constant data)
+        Assert.NotEqual(ttm3.Last.Value, ttm20.Last.Value);
+    }
+
+    [Fact]
+    public void TtmTrend_IsHot_AfterWarmup()
+    {
+        var ttm = new TtmTrend(DefaultPeriod);
+
+        // First bar: not hot
+        var bar1 = new TBar(DateTime.UtcNow, 100, 101, 99, 100, 1000);
+        ttm.Update(bar1, isNew: true);
+        Assert.False(ttm.IsHot);
+
+        // Second bar: should be hot (warmup period = 2)
+        var bar2 = new TBar(DateTime.UtcNow.AddMinutes(1), 101, 102, 100, 101, 1000);
+        ttm.Update(bar2, isNew: true);
+        Assert.True(ttm.IsHot);
+    }
+
+    [Fact]
+    public void TtmTrend_BarCorrection_IsNewFalse_RestoresState()
+    {
+        var bars = new GBM(sigma: 0.5, seed: 123).Fetch(50, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var ttm = new TtmTrend(DefaultPeriod);
+
+        // Process 30 bars
+        for (int i = 0; i < 30; i++)
+        {
+            ttm.Update(bars[i], isNew: true);
+        }
+
+        _ = ttm.Last.Value;
+
+        // Update bar 30 (isNew=true) then correct it (isNew=false) with same value
+        ttm.Update(bars[30], isNew: true);
+        double afterNew = ttm.Last.Value;
+
+        // Correct with isNew=false using same bar
+        ttm.Update(bars[30], isNew: false);
+        double afterCorrection = ttm.Last.Value;
+
+        // Bar correction with same data should produce the same value
+        Assert.Equal(afterNew, afterCorrection, precision: 10);
+    }
+}