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.
This commit is contained in:
Miha Kralj
2025-12-08 11:40:21 -08:00
parent ed5e5c8209
commit c2b33a8320
15 changed files with 33 additions and 46 deletions
+2 -1
View File
@@ -24,7 +24,8 @@
<!-- Include mock types -->
<Compile Include="Mocks\*.cs" />
<!-- Include test files -->
<Compile Include="*.Tests.cs" />
<Compile Include="**\*.Tests.cs" />
<Compile Include="..\lib\**\*.Quantower.Tests.cs" />
<!-- Include core library types -->
<Compile Include="..\lib\core\**\*.cs" Exclude="..\lib\core\**\*.Tests.cs" />
<!-- Include trends implementations -->
-170
View File
@@ -1,170 +0,0 @@
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);
}
}
-179
View File
@@ -1,179 +0,0 @@
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);
}
}
-169
View File
@@ -1,169 +0,0 @@
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);
}
}
-179
View File
@@ -1,179 +0,0 @@
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);
}
}
-170
View File
@@ -1,170 +0,0 @@
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);
}
}
-182
View File
@@ -1,182 +0,0 @@
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);
}
}
-173
View File
@@ -1,173 +0,0 @@
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
}
}
-177
View File
@@ -1,177 +0,0 @@
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);
}
}
-189
View File
@@ -1,189 +0,0 @@
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);
}
}
-190
View File
@@ -1,190 +0,0 @@
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);
}
}