gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-08-23 04:58:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
- 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
This commit is contained in:
Miha Kralj
2026-03-12 12:34:16 -07:00
parent 8937b0c0fa
commit 060649192f
1149 changed files with 1780 additions and 3316 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/dynamics/qstick/tests/Qstick.Quantower.Tests.cs
+806
View File
@@ -0,0 +1,806 @@
using TradingPlatform.BusinessLayer;
using Xunit;
namespace QuanTAlib.Tests;
public class QstickIndicatorTests
{
// ── Constructor & Defaults ──────────────────────────────────────────
[Fact]
public void Constructor_CreatesValidIndicator()
{
var indicator = new QstickIndicator();
Assert.NotNull(indicator);
Assert.Equal("Qstick Indicator", indicator.Name);
}
[Fact]
public void Constructor_Description_IsNotEmpty()
{
var indicator = new QstickIndicator();
Assert.False(string.IsNullOrWhiteSpace(indicator.Description));
Assert.Contains("candlestick", indicator.Description, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void Constructor_SeparateWindow_IsTrue()
{
var indicator = new QstickIndicator();
Assert.True(indicator.SeparateWindow);
}
[Fact]
public void Constructor_CreatesOneLineSeries()
{
var indicator = new QstickIndicator();
Assert.Single(indicator.LinesSeries);
}
[Fact]
public void Constructor_LineSeries_NameIsQstick()
{
var indicator = new QstickIndicator();
Assert.Equal("Qstick", indicator.LinesSeries[0].Name);
}
[Fact]
public void DefaultPeriod_Is14()
{
var indicator = new QstickIndicator();
Assert.Equal(14, indicator.Period);
}
[Fact]
public void DefaultMaType_IsSMA()
{
var indicator = new QstickIndicator();
Assert.Equal("SMA", indicator.MaType);
}
[Fact]
public void DefaultShowColdValues_IsTrue()
{
var indicator = new QstickIndicator();
Assert.True(indicator.ShowColdValues);
}
// ── ShortName ───────────────────────────────────────────────────────
[Fact]
public void ShortName_DefaultParameters_IncludesPeriodAndMaType()
{
var indicator = new QstickIndicator();
Assert.Equal("QSTICK(14,SMA)", indicator.ShortName);
}
[Fact]
public void ShortName_CustomPeriod_ReflectsNewPeriod()
{
var indicator = new QstickIndicator { Period = 20 };
Assert.Equal("QSTICK(20,SMA)", indicator.ShortName);
}
[Fact]
public void ShortName_EmaMode_IncludesEMA()
{
var indicator = new QstickIndicator { Period = 20, MaType = "EMA" };
Assert.Equal("QSTICK(20,EMA)", indicator.ShortName);
}
// ── MinHistoryDepths ────────────────────────────────────────────────
[Fact]
public void MinHistoryDepths_Static_EqualsZero()
{
Assert.Equal(0, QstickIndicator.MinHistoryDepths);
}
[Fact]
public void MinHistoryDepths_Interface_EqualsZero()
{
var indicator = new QstickIndicator();
IWatchlistIndicator watchlistIndicator = indicator;
Assert.Equal(0, watchlistIndicator.MinHistoryDepths);
}
// ── OnInit ──────────────────────────────────────────────────────────
[Fact]
public void Initialize_SmaMode_CreatesInternalIndicator()
{
var indicator = new QstickIndicator { MaType = "SMA" };
indicator.Initialize();
Assert.NotNull(indicator);
}
[Fact]
public void Initialize_EmaMode_CreatesInternalIndicator()
{
var indicator = new QstickIndicator { MaType = "EMA" };
indicator.Initialize();
Assert.NotNull(indicator);
}
[Fact]
public void Initialize_AddsZeroLineLevel()
{
var indicator = new QstickIndicator();
indicator.Initialize();
// OnInit calls AddLineLevel(0, "Zero", ...)
Assert.True(indicator.LineLevels.Count >= 1);
}
// ── ProcessUpdate: HistoricalBar ────────────────────────────────────
[Fact]
public void ProcessUpdate_HistoricalBar_ComputesValue()
{
var indicator = new QstickIndicator { Period = 3, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// After 5 bars with constant diff=5, Qstick=5
Assert.True(double.IsFinite(indicator.LinesSeries[0].GetValue(0)));
}
[Fact]
public void ProcessUpdate_HistoricalBar_BullishBars_PositiveValue()
{
var indicator = new QstickIndicator { Period = 3, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 3; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// All bullish, diff=5 each, SMA=5.0
Assert.Equal(5.0, indicator.LinesSeries[0].GetValue(0), 10);
}
// ── ProcessUpdate: NewBar ───────────────────────────────────────────
[Fact]
public void ProcessUpdate_NewBar_ComputesValue()
{
var indicator = new QstickIndicator { Period = 3, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
indicator.HistoricalData.AddBar(now, 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
indicator.HistoricalData.AddBar(now.AddMinutes(1), 100.0, 108.0, 95.0, 103.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
Assert.Equal(2, indicator.LinesSeries[0].Count);
}
// ── ProcessUpdate: NewTick ──────────────────────────────────────────
[Fact]
public void ProcessUpdate_NewTick_ProcessesWithoutError()
{
var indicator = new QstickIndicator { Period = 3, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
indicator.HistoricalData.AddBar(now, 100.0, 110.0, 95.0, 105.0, 1000);
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));
}
// ── SMA vs EMA ──────────────────────────────────────────────────────
[Fact]
public void SmaMode_BearishBars_ProducesNegativeQstick()
{
var indicator = new QstickIndicator { Period = 5, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 105.0, 90.0, 95.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// All bearish (close < open), diff=-5
Assert.Equal(-5.0, indicator.LinesSeries[0].GetValue(0), 10);
}
[Fact]
public void SmaMode_DojiBars_ProducesZeroQstick()
{
var indicator = new QstickIndicator { Period = 5, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 105.0, 95.0, 100.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
Assert.Equal(0.0, indicator.LinesSeries[0].GetValue(0), 10);
}
[Fact]
public void EmaMode_BullishBars_ProducesPositiveQstick()
{
var indicator = new QstickIndicator { Period = 5, MaType = "EMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
// All same diff=5, EMA converges to 5.0
Assert.Equal(5.0, indicator.LinesSeries[0].GetValue(0), 10);
}
// ── Core Calculation Integration ────────────────────────────────────
[Fact]
public void CalculationIntegration_SmaMode_ProducesCorrectValues()
{
var qstickCore = new Qstick(3);
var time = DateTime.UtcNow;
var bar1 = new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
var bar2 = new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000);
var bar3 = new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000);
qstickCore.Update(bar1);
qstickCore.Update(bar2);
var result = qstickCore.Update(bar3);
// SMA of (5, 3, 6) = 14/3 ≈ 4.667
Assert.Equal(14.0 / 3.0, result.Value, 10);
}
[Fact]
public void EmaMode_CalculatesCorrectly()
{
var qstickCore = new Qstick(3, useEma: true);
var time = DateTime.UtcNow;
// Bar 1: diff = 5
qstickCore.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
// Bar 2: diff = -3, EMA with alpha = 2/(3+1) = 0.5
var result = qstickCore.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 97.0, 1000));
// EMA = 0.5 * -3 + 0.5 * 5 = 1.0
Assert.Equal(1.0, result.Value, 10);
}
[Fact]
public void CalculationIntegration_MixedBullishBearish()
{
var qstickCore = new Qstick(4);
var time = DateTime.UtcNow;
// 2 bullish (diff=5), 2 bearish (diff=-5) → SMA = 0
qstickCore.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstickCore.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstickCore.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 90.0, 95.0, 1000));
var result = qstickCore.Update(new TBar(time.AddMinutes(3).Ticks, 100.0, 105.0, 90.0, 95.0, 1000));
Assert.Equal(0.0, result.Value, 10);
}
[Fact]
public void BullishBars_ProducePositiveQstick()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
qstick.Update(new TBar(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
}
Assert.True(qstick.Last.Value > 0);
Assert.Equal(5.0, qstick.Last.Value, 10);
}
[Fact]
public void BearishBars_ProduceNegativeQstick()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
qstick.Update(new TBar(time.AddMinutes(i).Ticks, 100.0, 105.0, 90.0, 95.0, 1000));
}
Assert.True(qstick.Last.Value < 0);
Assert.Equal(-5.0, qstick.Last.Value, 10);
}
[Fact]
public void DojiBars_ProduceZeroQstick()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
qstick.Update(new TBar(time.AddMinutes(i).Ticks, 100.0, 105.0, 95.0, 100.0, 1000));
}
Assert.Equal(0.0, qstick.Last.Value, 10);
}
// ── Core Indicator Features ─────────────────────────────────────────
[Fact]
public void CoreIndicator_ResetsCorrectly()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
Assert.NotEqual(default, qstick.Last);
qstick.Reset();
Assert.False(qstick.IsHot);
Assert.Equal(default, qstick.Last);
}
[Fact]
public void CoreIndicator_IsHot_SmaMode_AfterPeriodBars()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
Assert.False(qstick.IsHot);
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
Assert.False(qstick.IsHot);
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
Assert.False(qstick.IsHot);
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
Assert.True(qstick.IsHot);
}
[Fact]
public void CoreIndicator_IsHot_EmaMode_AfterFirstBar()
{
var qstick = new Qstick(3, useEma: true);
var time = DateTime.UtcNow;
Assert.False(qstick.IsHot);
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
Assert.True(qstick.IsHot);
}
[Fact]
public void CoreIndicator_Period_ReturnsConstructorValue()
{
var qstick = new Qstick(20);
Assert.Equal(20, qstick.Period);
}
[Fact]
public void CoreIndicator_UseEma_ReturnsConstructorValue()
{
var qstickSma = new Qstick(10, useEma: false);
Assert.False(qstickSma.UseEma);
var qstickEma = new Qstick(10, useEma: true);
Assert.True(qstickEma.UseEma);
}
[Fact]
public void CoreIndicator_WarmupPeriod_EqualsPeriod()
{
var qstick = new Qstick(20);
Assert.Equal(20, qstick.WarmupPeriod);
}
[Fact]
public void CoreIndicator_Name_SmaMode_DoesNotIncludeEma()
{
var qstick = new Qstick(14);
Assert.Equal("QSTICK(14)", qstick.Name);
}
[Fact]
public void CoreIndicator_Name_EmaMode_IncludesEma()
{
var qstick = new Qstick(14, useEma: true);
Assert.Equal("QSTICK(14,EMA)", qstick.Name);
}
[Fact]
public void CoreIndicator_InvalidPeriod_ThrowsArgumentException()
{
Assert.Throws<ArgumentException>(() => new Qstick(0));
Assert.Throws<ArgumentException>(() => new Qstick(-1));
}
// ── NaN/Infinity Handling ───────────────────────────────────────────
[Fact]
public void CoreIndicator_NaNOpen_ReturnsLastValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var firstResult = qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
var nanResult = qstick.Update(new TBar(time.AddMinutes(1).Ticks, double.NaN, 110.0, 95.0, 105.0, 1000));
Assert.Equal(firstResult.Value, nanResult.Value);
}
[Fact]
public void CoreIndicator_InfinityClose_ReturnsLastValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var firstResult = qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
var infResult = qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 110.0, 95.0, double.PositiveInfinity, 1000));
Assert.Equal(firstResult.Value, infResult.Value);
}
[Fact]
public void CoreIndicator_NegativeInfinityOpen_ReturnsLastValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var firstResult = qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
var infResult = qstick.Update(new TBar(time.AddMinutes(1).Ticks, double.NegativeInfinity, 110.0, 95.0, 105.0, 1000));
Assert.Equal(firstResult.Value, infResult.Value);
}
// ── Bar Correction (isNew=false) ────────────────────────────────────
[Fact]
public void CoreIndicator_BarCorrection_SmaMode_UpdatesLastBar()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 110.0, 95.0, 103.0, 1000));
// New bar
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000), isNew: true);
var afterNew = qstick.Last.Value;
// Correct the same bar (isNew=false)
var afterCorrection = qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 112.0, 93.0, 110.0, 1000), isNew: false);
// Value should change since close-open changed from 6 to 10
Assert.NotEqual(afterNew, afterCorrection.Value);
}
[Fact]
public void CoreIndicator_BarCorrection_EmaMode_RollsBackState()
{
var qstick = new Qstick(3, useEma: true);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
// New bar
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 108.0, 95.0, 106.0, 1000), isNew: true);
var afterNew = qstick.Last.Value;
// Correct the same bar (isNew=false)
var afterCorrection = qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 112.0, 93.0, 110.0, 1000), isNew: false);
Assert.NotEqual(afterNew, afterCorrection.Value);
}
// ── Batch / Update(TBarSeries) / Calculate ──────────────────────────
[Fact]
public void CoreIndicator_UpdateTBarSeries_ReturnsTSeries()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var series = new TBarSeries();
for (int i = 0; i < 5; i++)
{
series.Add(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0 + i, 1000);
}
var result = qstick.Update(series);
Assert.Equal(5, result.Count);
}
[Fact]
public void CoreIndicator_UpdateTBarSeries_EmptySeries_ReturnsEmpty()
{
var qstick = new Qstick(3);
var series = new TBarSeries();
var result = qstick.Update(series);
Assert.Empty(result);
}
[Fact]
public void CoreIndicator_Batch_ReturnsResults()
{
var time = DateTime.UtcNow;
var series = new TBarSeries();
for (int i = 0; i < 5; i++)
{
series.Add(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
}
var result = Qstick.Batch(series, period: 3);
Assert.Equal(5, result.Count);
}
[Fact]
public void CoreIndicator_BatchEma_ReturnsResults()
{
var time = DateTime.UtcNow;
var series = new TBarSeries();
for (int i = 0; i < 5; i++)
{
series.Add(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
}
var result = Qstick.Batch(series, period: 3, useEma: true);
Assert.Equal(5, result.Count);
Assert.Equal(5.0, result.Last.Value, 10);
}
[Fact]
public void CoreIndicator_Calculate_ReturnsResultsAndIndicator()
{
var time = DateTime.UtcNow;
var series = new TBarSeries();
for (int i = 0; i < 5; i++)
{
series.Add(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
}
var (results, indicator) = Qstick.Calculate(series, period: 3);
Assert.Equal(5, results.Count);
Assert.NotNull(indicator);
Assert.True(indicator.IsHot);
}
[Fact]
public void CoreIndicator_Prime_WarmsUpIndicator()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var series = new TBarSeries();
for (int i = 0; i < 5; i++)
{
series.Add(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
}
qstick.Prime(series);
Assert.True(qstick.IsHot);
Assert.Equal(5.0, qstick.Last.Value, 10);
}
// ── Pub Event ───────────────────────────────────────────────────────
[Fact]
public void CoreIndicator_PubEvent_FiresOnUpdate()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
int eventCount = 0;
qstick.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
Assert.Equal(2, eventCount);
}
[Fact]
public void CoreIndicator_PubEvent_NaN_StillFires()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
int eventCount = 0;
qstick.Pub += (object? sender, in TValueEventArgs args) => eventCount++;
qstick.Update(new TBar(time.Ticks, double.NaN, 110.0, 95.0, 105.0, 1000));
Assert.Equal(1, eventCount);
}
// ── Different Periods ───────────────────────────────────────────────
[Fact]
public void DifferentPeriods_ProduceDifferentResults()
{
var indicator1 = new QstickIndicator { Period = 3, MaType = "SMA" };
var indicator2 = new QstickIndicator { Period = 10, MaType = "SMA" };
indicator1.Initialize();
indicator2.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 10; i++)
{
double close = 105.0 + (i % 2 == 0 ? 3.0 : -3.0);
indicator1.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 115.0, 85.0, close, 1000);
indicator1.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
indicator2.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 115.0, 85.0, close, 1000);
indicator2.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
double val1 = indicator1.LinesSeries[0].GetValue(0);
double val2 = indicator2.LinesSeries[0].GetValue(0);
Assert.NotEqual(val1, val2);
}
[Fact]
public void SmaVsEma_SameData_ProduceDifferentResults()
{
var smaIndicator = new QstickIndicator { Period = 5, MaType = "SMA" };
var emaIndicator = new QstickIndicator { Period = 5, MaType = "EMA" };
smaIndicator.Initialize();
emaIndicator.Initialize();
var now = DateTime.UtcNow;
double[] closes = [105.0, 97.0, 108.0, 99.0, 102.0];
for (int i = 0; i < 5; i++)
{
smaIndicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 115.0, 85.0, closes[i], 1000);
smaIndicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
emaIndicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 115.0, 85.0, closes[i], 1000);
emaIndicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
double smaVal = smaIndicator.LinesSeries[0].GetValue(0);
double emaVal = emaIndicator.LinesSeries[0].GetValue(0);
// SMA = (5 + -3 + 8 + -1 + 2) / 5 = 11/5 = 2.2
Assert.Equal(2.2, smaVal, 10);
Assert.NotEqual(smaVal, emaVal);
}
// ── Reinit ──────────────────────────────────────────────────────────
[Fact]
public void Reinitialize_WithDifferentParameters_ResetsState()
{
var indicator = new QstickIndicator { Period = 5, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
indicator.Period = 10;
indicator.MaType = "EMA";
indicator.Initialize();
Assert.Equal("QSTICK(10,EMA)", indicator.ShortName);
}
// ── ShowColdValues ──────────────────────────────────────────────────
[Fact]
public void ShowColdValues_CanBeSetToFalse()
{
var indicator = new QstickIndicator { ShowColdValues = false };
Assert.False(indicator.ShowColdValues);
}
[Fact]
public void ShowColdValues_False_ProcessesWithoutError()
{
var indicator = new QstickIndicator { Period = 5, ShowColdValues = false };
indicator.Initialize();
var now = DateTime.UtcNow;
for (int i = 0; i < 2; i++)
{
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
}
Assert.NotNull(indicator);
}
// ── Multiple bars through adapter with known values ─────────────────
[Fact]
public void MultipleBars_ThroughAdapter_ProducesExpectedValues()
{
var indicator = new QstickIndicator { Period = 3, MaType = "SMA" };
indicator.Initialize();
var now = DateTime.UtcNow;
// Bar 1: diff = 5 (105-100)
indicator.HistoricalData.AddBar(now, 100.0, 110.0, 95.0, 105.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
// Bar 2: diff = 3 (103-100)
indicator.HistoricalData.AddBar(now.AddMinutes(1), 100.0, 105.0, 95.0, 103.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
// Bar 3: diff = 6 (106-100)
indicator.HistoricalData.AddBar(now.AddMinutes(2), 100.0, 108.0, 95.0, 106.0, 1000);
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
// SMA(3) of [5, 3, 6] = 14/3 ≈ 4.667
Assert.Equal(14.0 / 3.0, indicator.LinesSeries[0].GetValue(0), 10);
}
// ── Parameters can be modified ──────────────────────────────────────
[Fact]
public void Period_CanBeChanged()
{
var indicator = new QstickIndicator();
Assert.Equal(14, indicator.Period);
indicator.Period = 30;
Assert.Equal(30, indicator.Period);
}
[Fact]
public void MaType_CanBeChanged()
{
var indicator = new QstickIndicator();
Assert.Equal("SMA", indicator.MaType);
indicator.MaType = "EMA";
Assert.Equal("EMA", indicator.MaType);
}
}
lib/dynamics/qstick/tests/Qstick.Tests.cs
+557
View File
@@ -0,0 +1,557 @@
using Xunit;
namespace QuanTAlib.Tests;
public class QstickTests
{
// ═══════════════════════════════════════════════════════════════════════════
// Constructor Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Constructor_DefaultParameters_CreatesValidIndicator()
{
var qstick = new Qstick();
Assert.Equal(14, qstick.Period);
Assert.False(qstick.UseEma);
Assert.Equal("QSTICK(14)", qstick.Name);
}
[Fact]
public void Constructor_CustomPeriod_SetsCorrectly()
{
var qstick = new Qstick(20);
Assert.Equal(20, qstick.Period);
}
[Fact]
public void Constructor_EmaMode_SetsCorrectly()
{
var qstick = new Qstick(14, useEma: true);
Assert.True(qstick.UseEma);
Assert.Equal("QSTICK(14,EMA)", qstick.Name);
}
[Fact]
public void Constructor_PeriodLessThanOne_ThrowsException()
{
Assert.Throws<ArgumentException>(() => new Qstick(0));
}
[Fact]
public void Constructor_NegativePeriod_ThrowsException()
{
Assert.Throws<ArgumentException>(() => new Qstick(-1));
}
[Fact]
public void Constructor_PeriodOne_IsValid()
{
var qstick = new Qstick(1);
Assert.Equal(1, qstick.Period);
}
// ═══════════════════════════════════════════════════════════════════════════
// Basic Calculation Tests - SMA Mode
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_SingleBullishBar_ReturnsPositiveValue()
{
var qstick = new Qstick(1);
var bar = new TBar(DateTime.UtcNow.Ticks, 100.0, 105.0, 99.0, 105.0, 1000);
var result = qstick.Update(bar);
Assert.Equal(5.0, result.Value); // close - open = 105 - 100 = 5
}
[Fact]
public void Update_SingleBearishBar_ReturnsNegativeValue()
{
var qstick = new Qstick(1);
var bar = new TBar(DateTime.UtcNow.Ticks, 105.0, 105.0, 99.0, 100.0, 1000);
var result = qstick.Update(bar);
Assert.Equal(-5.0, result.Value); // close - open = 100 - 105 = -5
}
[Fact]
public void Update_DojiBar_ReturnsZero()
{
var qstick = new Qstick(1);
var bar = new TBar(DateTime.UtcNow.Ticks, 100.0, 105.0, 99.0, 100.0, 1000);
var result = qstick.Update(bar);
Assert.Equal(0.0, result.Value); // close - open = 100 - 100 = 0
}
[Fact]
public void Update_ThreeBars_CalculatesCorrectSMA()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
// Bar 1: +5 (bullish)
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
// Bar 2: -3 (bearish)
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 97.0, 1000));
// Bar 3: +2 (bullish)
var result = qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
// SMA = (5 + -3 + 2) / 3 = 4/3 ≈ 1.333
Assert.Equal(4.0 / 3.0, result.Value, 10);
Assert.True(qstick.IsHot);
}
[Fact]
public void Update_NotWarmUp_ReturnsPartialAverage()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
// Bar 1: +5
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
// Bar 2: +3
var result = qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
// Partial average = (5 + 3) / 2 = 4
Assert.Equal(4.0, result.Value, 10);
Assert.False(qstick.IsHot);
}
// ═══════════════════════════════════════════════════════════════════════════
// Basic Calculation Tests - EMA Mode
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_EmaMode_FirstBar_ReturnsDiff()
{
var qstick = new Qstick(14, useEma: true);
var bar = new TBar(DateTime.UtcNow.Ticks, 100.0, 105.0, 99.0, 105.0, 1000);
var result = qstick.Update(bar);
Assert.Equal(5.0, result.Value);
}
[Fact]
public void Update_EmaMode_MultipleBar_CalculatesEma()
{
var qstick = new Qstick(3, useEma: true); // alpha = 2/(3+1) = 0.5
var time = DateTime.UtcNow;
// Bar 1: diff = 5
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
// Bar 2: diff = -3, EMA = 0.5 * -3 + 0.5 * 5 = 1.0
var result = qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 97.0, 1000));
Assert.Equal(1.0, result.Value, 10);
}
[Fact]
public void Update_EmaMode_IsHotFromFirstBar()
{
var qstick = new Qstick(14, useEma: true);
var bar = new TBar(DateTime.UtcNow.Ticks, 100.0, 105.0, 99.0, 105.0, 1000);
qstick.Update(bar);
Assert.True(qstick.IsHot);
}
// ═══════════════════════════════════════════════════════════════════════════
// Bar Correction Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_IsNewFalse_CorrectsPreviousBar()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
// Bar 1
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
// Bar 2
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
// Bar 3 initial
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
// Bar 3 correction (close changes from 102 to 108)
var result = qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 108.0, 1000), isNew: false);
// SMA = (5 + 3 + 8) / 3 = 16/3 ≈ 5.333
Assert.Equal(16.0 / 3.0, result.Value, 10);
}
[Fact]
public void Update_MultipleCorrections_ProducesSameResult()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
// Multiple corrections to same bar should be idempotent
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 107.0, 1000), isNew: false);
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 107.0, 1000), isNew: false);
var result = qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 107.0, 1000), isNew: false);
// SMA = (5 + 3 + 7) / 3 = 15/3 = 5
Assert.Equal(5.0, result.Value, 10);
}
[Fact]
public void Update_EmaMode_BarCorrection_Works()
{
var qstick = new Qstick(3, useEma: true); // alpha = 0.5
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000)); // diff=5, ema=5
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000)); // diff=3, ema=0.5*3+0.5*5=4
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 95.0, 102.0, 1000)); // diff=2, ema=0.5*2+0.5*4=3
// Correct bar 3: diff changes from 2 to 8
var result = qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 108.0, 1000), isNew: false);
// ema = 0.5*8 + 0.5*4 = 6
Assert.Equal(6.0, result.Value, 10);
}
// ═══════════════════════════════════════════════════════════════════════════
// Edge Case Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_NaNOpen_ReturnsLastValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var bar1 = new TBar(time.Ticks, 100.0, 105.0, 99.0, 105.0, 1000);
var result1 = qstick.Update(bar1);
var bar2 = new TBar(time.AddMinutes(1).Ticks, double.NaN, 105.0, 99.0, 105.0, 1000);
var result2 = qstick.Update(bar2);
Assert.Equal(result1.Value, result2.Value);
}
[Fact]
public void Update_NaNClose_ReturnsLastValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var bar1 = new TBar(time.Ticks, 100.0, 105.0, 99.0, 105.0, 1000);
var result1 = qstick.Update(bar1);
var bar2 = new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 99.0, double.NaN, 1000);
var result2 = qstick.Update(bar2);
Assert.Equal(result1.Value, result2.Value);
}
[Fact]
public void Update_InfinityInput_ReturnsLastValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
var bar1 = new TBar(time.Ticks, 100.0, 105.0, 99.0, 105.0, 1000);
var result1 = qstick.Update(bar1);
var bar2 = new TBar(time.AddMinutes(1).Ticks, double.PositiveInfinity, 105.0, 99.0, 105.0, 1000);
var result2 = qstick.Update(bar2);
Assert.Equal(result1.Value, result2.Value);
}
[Fact]
public void Update_LargeValues_CalculatesCorrectly()
{
var qstick = new Qstick(1);
var bar = new TBar(DateTime.UtcNow.Ticks, 1e10, 1.1e10, 0.9e10, 1.05e10, 1000);
var result = qstick.Update(bar);
Assert.Equal(0.05e10, result.Value, 1);
}
[Fact]
public void Update_SmallValues_CalculatesCorrectly()
{
var qstick = new Qstick(1);
var bar = new TBar(DateTime.UtcNow.Ticks, 0.0001, 0.00015, 0.00009, 0.00012, 1000);
var result = qstick.Update(bar);
Assert.Equal(0.00002, result.Value, 10);
}
// ═══════════════════════════════════════════════════════════════════════════
// Reset Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Reset_ClearsState()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
Assert.True(qstick.IsHot);
qstick.Reset();
Assert.False(qstick.IsHot);
Assert.Equal(default, qstick.Last);
}
[Fact]
public void Reset_EmaMode_ClearsState()
{
var qstick = new Qstick(3, useEma: true);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
Assert.True(qstick.IsHot);
qstick.Reset();
Assert.False(qstick.IsHot);
}
[Fact]
public void Reset_CanReuseAfterReset()
{
var qstick = new Qstick(2);
var time = DateTime.UtcNow;
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
qstick.Reset();
// New data after reset
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 105.0, 95.0, 98.0, 1000)); // diff = -2
var result = qstick.Update(new TBar(time.AddMinutes(3).Ticks, 100.0, 105.0, 95.0, 106.0, 1000)); // diff = 6
// SMA = (-2 + 6) / 2 = 2
Assert.Equal(2.0, result.Value, 10);
Assert.True(qstick.IsHot);
}
// ═══════════════════════════════════════════════════════════════════════════
// Batch Processing Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_BarSeries_ReturnsCorrectLength()
{
var qstick = new Qstick(3);
var bars = new TBarSeries();
var time = DateTime.UtcNow;
bars.Add(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
bars.Add(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
bars.Add(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000));
var result = qstick.Update(bars);
Assert.Equal(3, result.Count);
}
[Fact]
public void Update_BarSeries_LastValueMatchesLast()
{
var qstick = new Qstick(3);
var bars = new TBarSeries();
var time = DateTime.UtcNow;
bars.Add(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
bars.Add(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
bars.Add(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000));
var result = qstick.Update(bars);
Assert.Equal(qstick.Last.Value, result.Values[^1], 10);
}
[Fact]
public void Update_EmptyBarSeries_ReturnsEmpty()
{
var qstick = new Qstick(3);
var bars = new TBarSeries();
var result = qstick.Update(bars);
Assert.True(result.Count == 0);
}
[Fact]
public void Batch_ReturnsCorrectResults()
{
var bars = new TBarSeries();
var time = DateTime.UtcNow;
bars.Add(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000)); // diff = 5
bars.Add(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000)); // diff = 3
bars.Add(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000)); // diff = 6
var result = Qstick.Batch(bars, period: 3);
// Last value = SMA(5, 3, 6) = 14/3 ≈ 4.667
Assert.Equal(14.0 / 3.0, result.Values[^1], 10);
}
[Fact]
public void Calculate_ReturnsIndicatorAndResults()
{
var bars = new TBarSeries();
var time = DateTime.UtcNow;
bars.Add(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
bars.Add(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
bars.Add(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000));
var (results, indicator) = Qstick.Calculate(bars, period: 3);
Assert.Equal(3, results.Count);
Assert.True(indicator.IsHot);
Assert.Equal(3, indicator.Period);
}
// ═══════════════════════════════════════════════════════════════════════════
// Prime Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Prime_WarmUpIndicator()
{
var qstick = new Qstick(3);
var bars = new TBarSeries();
var time = DateTime.UtcNow;
bars.Add(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000));
bars.Add(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 95.0, 103.0, 1000));
bars.Add(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 106.0, 1000));
qstick.Prime(bars);
Assert.True(qstick.IsHot);
Assert.NotEqual(default, qstick.Last);
}
// ═══════════════════════════════════════════════════════════════════════════
// Event Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_RaisesPubEvent()
{
var qstick = new Qstick(3);
var eventRaised = false;
TValue receivedValue = default;
qstick.Pub += (object? sender, in TValueEventArgs args) =>
{
eventRaised = true;
receivedValue = args.Value;
};
var bar = new TBar(DateTime.UtcNow.Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
var result = qstick.Update(bar);
Assert.True(eventRaised);
Assert.Equal(result.Value, receivedValue.Value);
}
// ═══════════════════════════════════════════════════════════════════════════
// Property Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void WarmupPeriod_EqualsPeriod()
{
var qstick = new Qstick(20);
Assert.Equal(20, qstick.WarmupPeriod);
}
[Fact]
public void IsHot_SmaMode_FalseBeforeFullPeriod()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
for (int i = 0; i < 4; i++)
{
qstick.Update(new TBar(time.AddMinutes(i).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
Assert.False(qstick.IsHot);
}
qstick.Update(new TBar(time.AddMinutes(4).Ticks, 100.0, 105.0, 95.0, 102.0, 1000));
Assert.True(qstick.IsHot);
}
// ═══════════════════════════════════════════════════════════════════════════
// Consistency Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Update_BatchVsStreaming_ProducesSameResults()
{
var bars = new TBarSeries();
var time = DateTime.UtcNow;
for (int i = 0; i < 20; i++)
{
double open = 100.0 + i * 0.5;
double close = open + (i % 3 - 1); // varies between -1, 0, 1
bars.Add(new TBar(time.AddMinutes(i).Ticks, open, open + 2, open - 1, close, 1000));
}
// Batch processing
var batchQstick = new Qstick(5);
var batchResult = batchQstick.Update(bars);
// Streaming processing
var streamQstick = new Qstick(5);
var streamResults = new List<double>();
for (int i = 0; i < bars.Count; i++)
{
var result = streamQstick.Update(bars[i]);
streamResults.Add(result.Value);
}
// Compare results
for (int i = 0; i < bars.Count; i++)
{
Assert.Equal(batchResult.Values[i], streamResults[i], 10);
}
}
[Fact]
public void SmaVsEma_DifferentResults()
{
var bars = new TBarSeries();
var time = DateTime.UtcNow;
for (int i = 0; i < 10; i++)
{
double open = 100.0;
double close = 100.0 + (i % 2 == 0 ? 5 : -3);
bars.Add(new TBar(time.AddMinutes(i).Ticks, open, 110.0, 95.0, close, 1000));
}
var smaQstick = new Qstick(5, useEma: false);
var emaQstick = new Qstick(5, useEma: true);
var smaResult = smaQstick.Update(bars);
var emaResult = emaQstick.Update(bars);
// SMA and EMA should produce different results (EMA weights more recent)
Assert.NotEqual(smaResult.Values[^1], emaResult.Values[^1]);
}
}
lib/dynamics/qstick/tests/Qstick.Validation.Tests.cs
+424
View File
@@ -0,0 +1,424 @@
using Xunit;
using Xunit.Abstractions;
namespace QuanTAlib.Tests;
/// <summary>
/// Validation tests for Qstick indicator.
/// Validates against manual formula calculations and Tulip Indicators qstick.
/// Qstick is not available in TA-Lib, Skender, or Ooples.
/// </summary>
public sealed class QstickValidationTests : IDisposable
{
private readonly ValidationTestData _data;
private readonly ITestOutputHelper _output;
public QstickValidationTests(ITestOutputHelper output)
{
_output = output;
_data = new ValidationTestData();
}
public void Dispose()
{
_data.Dispose();
}
// ═══════════════════════════════════════════════════════════════════════════
// Mathematical Correctness Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void ManualCalculation_MatchesFormula()
{
var bars = new TBarSeries();
var time = DateTime.UtcNow;
// Create known bars
bars.Add(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000)); // diff = 5
bars.Add(new TBar(time.AddMinutes(1).Ticks, 100.0, 108.0, 92.0, 97.0, 1000)); // diff = -3
bars.Add(new TBar(time.AddMinutes(2).Ticks, 100.0, 106.0, 94.0, 104.0, 1000)); // diff = 4
bars.Add(new TBar(time.AddMinutes(3).Ticks, 100.0, 107.0, 93.0, 98.0, 1000)); // diff = -2
bars.Add(new TBar(time.AddMinutes(4).Ticks, 100.0, 109.0, 91.0, 106.0, 1000)); // diff = 6
var qstick = new Qstick(5);
for (int i = 0; i < bars.Count; i++)
{
qstick.Update(bars[i]);
}
// Expected: SMA of (5, -3, 4, -2, 6) = 10/5 = 2.0
Assert.Equal(2.0, qstick.Last.Value, 10);
}
[Fact]
public void ManualCalculation_Period3()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
// Bar 1: diff = 8
qstick.Update(new TBar(time.Ticks, 100.0, 115.0, 95.0, 108.0, 1000));
// Bar 2: diff = -4
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 102.0, 90.0, 96.0, 1000));
// Bar 3: diff = 6
var result = qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 106.0, 1000));
// Expected: SMA(8, -4, 6) = 10/3 ≈ 3.333
Assert.Equal(10.0 / 3.0, result.Value, 10);
}
[Fact]
public void ManualCalculation_Period7()
{
var qstick = new Qstick(7);
var time = DateTime.UtcNow;
double[] diffs = { 5, -3, 4, -2, 6, -1, 3 };
for (int i = 0; i < diffs.Length; i++)
{
double open = 100.0;
double close = 100.0 + diffs[i];
qstick.Update(new TBar(time.AddMinutes(i).Ticks, open, 110.0, 90.0, close, 1000));
}
// Expected: SMA of 5, -3, 4, -2, 6, -1, 3 = 12/7 ≈ 1.714
double expectedSum = 5 - 3 + 4 - 2 + 6 - 1 + 3; // = 12
Assert.Equal(expectedSum / 7.0, qstick.Last.Value, 10);
}
[Fact]
public void EmaCalculation_MatchesFormula()
{
var qstick = new Qstick(3, useEma: true); // alpha = 2/(3+1) = 0.5
var time = DateTime.UtcNow;
// Bar 1: diff = 10
qstick.Update(new TBar(time.Ticks, 100.0, 115.0, 95.0, 110.0, 1000));
Assert.Equal(10.0, qstick.Last.Value, 10);
// Bar 2: diff = -6, EMA = 0.5 * -6 + 0.5 * 10 = 2.0
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 102.0, 90.0, 94.0, 1000));
Assert.Equal(2.0, qstick.Last.Value, 10);
// Bar 3: diff = 4, EMA = 0.5 * 4 + 0.5 * 2 = 3.0
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 108.0, 95.0, 104.0, 1000));
Assert.Equal(3.0, qstick.Last.Value, 10);
}
[Fact]
public void EmaCalculation_Period5()
{
var qstick = new Qstick(5, useEma: true); // alpha = 2/(5+1) = 1/3
var time = DateTime.UtcNow;
double alpha = 2.0 / 6.0;
// Bar 1: diff = 6
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 106.0, 1000));
double expectedEma = 6.0;
Assert.Equal(expectedEma, qstick.Last.Value, 10);
// Bar 2: diff = 3, EMA = alpha * 3 + (1-alpha) * 6-
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 108.0, 96.0, 103.0, 1000));
expectedEma = alpha * 3 + (1 - alpha) * expectedEma;
Assert.Equal(expectedEma, qstick.Last.Value, 10);
}
// ═══════════════════════════════════════════════════════════════════════════
// Edge Case Validation
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void ZeroCrossing_IdentifiesCorrectly()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
// Start bullish
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 106.0, 1000)); // +6
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 108.0, 92.0, 104.0, 1000)); // +4
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 106.0, 94.0, 102.0, 1000)); // +2
Assert.True(qstick.Last.Value > 0);
// Shift to bearish
qstick.Update(new TBar(time.AddMinutes(3).Ticks, 100.0, 105.0, 90.0, 92.0, 1000)); // -8
qstick.Update(new TBar(time.AddMinutes(4).Ticks, 100.0, 104.0, 88.0, 90.0, 1000)); // -10
qstick.Update(new TBar(time.AddMinutes(5).Ticks, 100.0, 103.0, 86.0, 88.0, 1000)); // -12
Assert.True(qstick.Last.Value < 0);
}
[Fact]
public void LargeGaps_HandledCorrectly()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
// Gap up scenario - previous close has no effect on body calculation
qstick.Update(new TBar(time.Ticks, 100.0, 105.0, 95.0, 103.0, 1000)); // diff = 3
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 110.0, 118.0, 108.0, 115.0, 1000)); // diff = 5 (gap up)
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 120.0, 125.0, 118.0, 122.0, 1000)); // diff = 2 (gap up)
// SMA = (3 + 5 + 2) / 3 = 10/3 ≈ 3.333
Assert.Equal(10.0 / 3.0, qstick.Last.Value, 10);
}
[Fact]
public void AlternatingBullishBearish_AveragesToNearZero()
{
var qstick = new Qstick(4);
var time = DateTime.UtcNow;
// Alternating pattern
qstick.Update(new TBar(time.Ticks, 100.0, 110.0, 95.0, 105.0, 1000)); // +5
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 105.0, 90.0, 95.0, 1000)); // -5
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 110.0, 95.0, 105.0, 1000)); // +5
qstick.Update(new TBar(time.AddMinutes(3).Ticks, 100.0, 105.0, 90.0, 95.0, 1000)); // -5
// SMA = (5 - 5 + 5 - 5) / 4 = 0
Assert.Equal(0.0, qstick.Last.Value, 10);
}
[Fact]
public void AllDoji_ReturnsZero()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
for (int i = 0; i < 5; i++)
{
qstick.Update(new TBar(time.AddMinutes(i).Ticks, 100.0, 105.0, 95.0, 100.0, 1000)); // diff = 0
}
Assert.Equal(0.0, qstick.Last.Value, 10);
}
// ═══════════════════════════════════════════════════════════════════════════
// Stability Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void LongSeries_MaintainsStability()
{
var qstick = new Qstick(14);
var results = new List<double>();
for (int i = 0; i < _data.Bars.Count; i++)
{
var result = qstick.Update(_data.Bars[i]);
results.Add(result.Value);
}
// Verify no NaN or Infinity after warmup
for (int i = 14; i < results.Count; i++)
{
Assert.True(double.IsFinite(results[i]), $"Result at index {i} is not finite: {results[i]}");
}
}
[Fact]
public void BatchVsStreaming_MatchesExactly()
{
// Batch processing
var batchResults = Qstick.Batch(_data.Bars, period: 14);
// Streaming processing
var streamQstick = new Qstick(14);
var streamResults = new List<double>();
for (int i = 0; i < _data.Bars.Count; i++)
{
var result = streamQstick.Update(_data.Bars[i]);
streamResults.Add(result.Value);
}
// Compare
Assert.Equal(batchResults.Count, streamResults.Count);
for (int i = 0; i < batchResults.Count; i++)
{
Assert.Equal(batchResults.Values[i], streamResults[i], 12);
}
}
[Fact]
public void SmaVsEma_ConvergesOverLongPeriod()
{
// With constant input, SMA and EMA should converge
var smaQstick = new Qstick(10, useEma: false);
var emaQstick = new Qstick(10, useEma: true);
var time = DateTime.UtcNow;
// Feed constant bars (close - open = 5)
for (int i = 0; i < 100; i++)
{
var bar = new TBar(time.AddMinutes(i).Ticks, 100.0, 110.0, 95.0, 105.0, 1000);
smaQstick.Update(bar);
emaQstick.Update(bar);
}
// Both should converge to 5.0 with constant input
Assert.Equal(5.0, smaQstick.Last.Value, 10);
Assert.Equal(5.0, emaQstick.Last.Value, 4); // EMA converges slower
}
// ═══════════════════════════════════════════════════════════════════════════
// Period Boundary Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Period1_ReturnsDiffDirectly()
{
var qstick = new Qstick(1);
var time = DateTime.UtcNow;
var bar = new TBar(time.Ticks, 100.0, 110.0, 95.0, 107.0, 1000);
var result = qstick.Update(bar);
Assert.Equal(7.0, result.Value, 10); // close - open = 107 - 100 = 7
}
[Fact]
public void LargePeriod_CalculatesCorrectly()
{
var qstick = new Qstick(50);
var results = new List<double>();
for (int i = 0; i < _data.Bars.Count; i++)
{
var result = qstick.Update(_data.Bars[i]);
results.Add(result.Value);
}
// Verify indicator is hot after warmup
Assert.True(qstick.IsHot);
// Verify values are finite after warmup
for (int i = 50; i < results.Count; i++)
{
Assert.True(double.IsFinite(results[i]), $"Result at index {i} is not finite");
}
}
// ═══════════════════════════════════════════════════════════════════════════
// Rolling Window Tests
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void RollingWindow_DropsOldestValue()
{
var qstick = new Qstick(3);
var time = DateTime.UtcNow;
// Fill window: +10, +10, +10
qstick.Update(new TBar(time.Ticks, 100.0, 115.0, 95.0, 110.0, 1000));
qstick.Update(new TBar(time.AddMinutes(1).Ticks, 100.0, 115.0, 95.0, 110.0, 1000));
qstick.Update(new TBar(time.AddMinutes(2).Ticks, 100.0, 115.0, 95.0, 110.0, 1000));
Assert.Equal(10.0, qstick.Last.Value, 10);
// Add -20 (replaces oldest +10)
qstick.Update(new TBar(time.AddMinutes(3).Ticks, 100.0, 105.0, 75.0, 80.0, 1000));
// Window is now: +10, +10, -20 → SMA = 0/3 = 0
Assert.Equal(0.0, qstick.Last.Value, 10);
}
[Fact]
public void RollingWindow_MaintainsCorrectSum()
{
var qstick = new Qstick(5);
var time = DateTime.UtcNow;
// Create predictable pattern
double[] diffs = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < diffs.Length; i++)
{
double open = 100.0;
double close = 100.0 + diffs[i];
qstick.Update(new TBar(time.AddMinutes(i).Ticks, open, 110.0, 90.0, close, 1000));
if (i >= 4) // After warmup
{
// Expected: SMA of last 5 values
double expectedSum = 0;
for (int j = i - 4; j <= i; j++)
{
expectedSum += diffs[j];
}
Assert.Equal(expectedSum / 5.0, qstick.Last.Value, 10);
}
}
}
// ═══════════════════════════════════════════════════════════════════════════
// Tulip Indicators Cross-Validation
// ═══════════════════════════════════════════════════════════════════════════
[Fact]
public void Validate_Tulip_Qstick()
{
// Tulip qstick: inputs = {open[], close[]}, options = {period}, outputs = {qstick[]}
// Formula: SMA(close - open, period) — same as QuanTAlib Qstick with useEma=false
int period = 14;
double[] openData = _data.OpenPrices.ToArray();
double[] closeData = _data.ClosePrices.ToArray();
// QuanTAlib batch
var qSeries = Qstick.Batch(_data.Bars, period);
double[] qResult = new double[qSeries.Count];
for (int i = 0; i < qSeries.Count; i++)
{
qResult[i] = qSeries[i].Value;
}
// Tulip qstick
var indicator = Tulip.Indicators.qstick;
double[][] inputs = { openData, closeData };
double[] options = { period };
double[][] outputs = { new double[openData.Length] };
indicator.Run(inputs, options, outputs);
double[] tResult = outputs[0];
// Tulip output is shorter by (period-1) — lookback = period - 1
int lookback = period - 1;
ValidationHelper.VerifyData(qResult, tResult, lookback);
_output.WriteLine($"Qstick validated against Tulip Indicators (period={period})");
}
[Fact]
public void Validate_Tulip_Qstick_MultiplePeriods()
{
int[] periods = { 5, 10, 20, 50 };
foreach (int period in periods)
{
double[] openData = _data.OpenPrices.ToArray();
double[] closeData = _data.ClosePrices.ToArray();
var qSeries = Qstick.Batch(_data.Bars, period);
double[] qResult = new double[qSeries.Count];
for (int i = 0; i < qSeries.Count; i++)
{
qResult[i] = qSeries[i].Value;
}
var indicator = Tulip.Indicators.qstick;
double[][] inputs = { openData, closeData };
double[] options = { period };
double[][] outputs = { new double[openData.Length] };
indicator.Run(inputs, options, outputs);
double[] tResult = outputs[0];
int lookback = period - 1;
ValidationHelper.VerifyData(qResult, tResult, lookback);
}
_output.WriteLine("Qstick validated against Tulip for multiple periods (5, 10, 20, 50)");
}
}