mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-07-31 10:57:43 +00:00
Miha Kralj
060649192f
- 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
691 lines
19 KiB
C#
691 lines
19 KiB
C#
using Xunit;
|
|
|
|
namespace QuanTAlib.Tests;
|
|
|
|
public class VrocTests
|
|
{
|
|
private const double Tolerance = 1e-10;
|
|
private readonly GBM _gbm;
|
|
private readonly TBarSeries _bars;
|
|
|
|
public VrocTests()
|
|
{
|
|
_gbm = new GBM(seed: 42);
|
|
_bars = _gbm.Fetch(200, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
|
|
}
|
|
|
|
#region Constructor Tests
|
|
|
|
[Fact]
|
|
public void Constructor_DefaultParameters_SetsExpectedValues()
|
|
{
|
|
var vroc = new Vroc();
|
|
Assert.Equal("Vroc(12,%)", vroc.Name);
|
|
Assert.Equal(13, vroc.WarmupPeriod);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_CustomPeriod_SetsExpectedValues()
|
|
{
|
|
var vroc = new Vroc(period: 20);
|
|
Assert.Equal("Vroc(20,%)", vroc.Name);
|
|
Assert.Equal(21, vroc.WarmupPeriod);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_PointMode_SetsExpectedName()
|
|
{
|
|
var vroc = new Vroc(period: 10, usePercent: false);
|
|
Assert.Equal("Vroc(10,pt)", vroc.Name);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_PeriodLessThan1_ThrowsArgumentException()
|
|
{
|
|
var ex = Assert.Throws<ArgumentException>(() => new Vroc(period: 0));
|
|
Assert.Equal("period", ex.ParamName);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Basic Calculation Tests
|
|
|
|
[Fact]
|
|
public void Update_ReturnsTValue()
|
|
{
|
|
var vroc = new Vroc();
|
|
var result = vroc.Update(_bars[0]);
|
|
Assert.IsType<TValue>(result);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_AccessesLast()
|
|
{
|
|
var vroc = new Vroc();
|
|
vroc.Update(_bars[0]);
|
|
Assert.Equal(vroc.Last.Value, vroc.Update(_bars[0], isNew: false).Value);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_SameVolumes_ReturnsZeroPercent()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: true);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// All same volumes should result in VROC = 0
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
Assert.Equal(0.0, vroc.Last.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_SameVolumes_ReturnsZeroPoint()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: false);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// All same volumes should result in VROC = 0
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
Assert.Equal(0.0, vroc.Last.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_DoubleVolume_Returns100Percent()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: true);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Initial volumes of 1000 - need period+1 bars to get first VROC value
|
|
// VROC compares current volume to volume 'period' bars ago
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Double the volume - compares 2000 to volume[4-3]=volume[1]=1000
|
|
var doubleBar = new TBar(now.AddMinutes(4), 100, 100, 100, 100, 2000);
|
|
var result = vroc.Update(doubleBar, isNew: true);
|
|
|
|
// (2000 - 1000) / 1000 * 100 = 100
|
|
Assert.Equal(100.0, result.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_DoubleVolume_Returns1000Point()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: false);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Need period+1 bars to get first VROC value
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Double the volume - compares 2000 to volume[4-3]=volume[1]=1000
|
|
var doubleBar = new TBar(now.AddMinutes(4), 100, 100, 100, 100, 2000);
|
|
var result = vroc.Update(doubleBar, isNew: true);
|
|
|
|
// 2000 - 1000 = 1000
|
|
Assert.Equal(1000.0, result.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_HalfVolume_ReturnsMinus50Percent()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: true);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Need period+1 bars to get first VROC value
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Half the volume - compares 500 to volume[4-3]=volume[1]=1000
|
|
var halfBar = new TBar(now.AddMinutes(4), 100, 100, 100, 100, 500);
|
|
var result = vroc.Update(halfBar, isNew: true);
|
|
|
|
// (500 - 1000) / 1000 * 100 = -50
|
|
Assert.Equal(-50.0, result.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_IncreasingVolumes_ReturnsPositive()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: true);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Increasing volumes
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000 + i * 100);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
Assert.True(vroc.Last.Value > 0, $"Expected positive VROC but got {vroc.Last.Value}");
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_DecreasingVolumes_ReturnsNegative()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: true);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Decreasing volumes
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 2000 - i * 100);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
Assert.True(vroc.Last.Value < 0, $"Expected negative VROC but got {vroc.Last.Value}");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region State Management Tests
|
|
|
|
[Fact]
|
|
public void IsNew_True_AdvancesState()
|
|
{
|
|
var vroc = new Vroc(period: 3);
|
|
|
|
// Feed bars and capture the last values from two consecutive new bars
|
|
// Use GBM data which has varying volumes
|
|
var result1 = vroc.Update(_bars[0], isNew: true);
|
|
for (int i = 1; i < 20; i++)
|
|
{
|
|
result1 = vroc.Update(_bars[i], isNew: true);
|
|
}
|
|
|
|
var result2 = vroc.Update(_bars[20], isNew: true);
|
|
|
|
// Two consecutive bars with isNew=true should (likely) have different values
|
|
// This confirms state advances on new bars. Since GBM generates varying data,
|
|
// consecutive VROC values will differ
|
|
Assert.True(vroc.IsHot, "VROC should be hot after 20 bars");
|
|
// Just verify the indicator is working - different bars produce results
|
|
Assert.True(result1.Value != result2.Value || Math.Abs(result2.Value) > 0 || Math.Abs(result1.Value) > 0,
|
|
$"State should have advanced. Result1={result1.Value}, Result2={result2.Value}");
|
|
}
|
|
|
|
[Fact]
|
|
public void IsNew_False_UpdatesCurrentBar()
|
|
{
|
|
var vroc = new Vroc(period: 3);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Fill buffer
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
var stateBeforeCorrection = vroc.Last.Value;
|
|
|
|
// Correction with different volume
|
|
var correctionBar = new TBar(now.AddMinutes(3), 100, 100, 100, 100, 1500);
|
|
vroc.Update(correctionBar, isNew: false);
|
|
|
|
// Restore original
|
|
var originalBar = new TBar(now.AddMinutes(3), 100, 100, 100, 100, 1000);
|
|
var result = vroc.Update(originalBar, isNew: false);
|
|
|
|
Assert.Equal(stateBeforeCorrection, result.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void IterativeCorrections_RestoreState()
|
|
{
|
|
var vroc = new Vroc(period: 5);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Add several bars
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 1000 + i * 50);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
var stateBeforeCorrections = vroc.Last.Value;
|
|
|
|
// Apply multiple corrections
|
|
for (int j = 0; j < 5; j++)
|
|
{
|
|
var correctionBar = new TBar(now.AddMinutes(9), 100, 100, 100, 100, 2000 + j * 100);
|
|
vroc.Update(correctionBar, isNew: false);
|
|
}
|
|
|
|
// Restore original bar
|
|
var originalBar = new TBar(now.AddMinutes(9), 100, 100, 100, 100, 1450);
|
|
var restored = vroc.Update(originalBar, isNew: false);
|
|
|
|
Assert.Equal(stateBeforeCorrections, restored.Value, Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void Reset_ClearsState()
|
|
{
|
|
var vroc = new Vroc();
|
|
|
|
// Process some bars
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
vroc.Update(_bars[i], isNew: true);
|
|
}
|
|
|
|
Assert.True(vroc.IsHot);
|
|
|
|
vroc.Reset();
|
|
|
|
Assert.False(vroc.IsHot);
|
|
Assert.Equal(default, vroc.Last);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Warmup Tests
|
|
|
|
[Fact]
|
|
public void IsHot_BeforeWarmup_ReturnsFalse()
|
|
{
|
|
var vroc = new Vroc(period: 10);
|
|
var now = DateTime.UtcNow;
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
|
|
vroc.Update(bar, isNew: true);
|
|
Assert.False(vroc.IsHot, $"Should not be hot at index {i}");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void IsHot_AfterWarmup_ReturnsTrue()
|
|
{
|
|
var vroc = new Vroc(period: 10);
|
|
var now = DateTime.UtcNow;
|
|
|
|
for (int i = 0; i < 11; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
Assert.True(vroc.IsHot);
|
|
}
|
|
|
|
[Fact]
|
|
public void WarmupPeriod_EqualsPeriodPlusOne()
|
|
{
|
|
var vroc = new Vroc(period: 15);
|
|
Assert.Equal(16, vroc.WarmupPeriod);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Robustness Tests
|
|
|
|
[Fact]
|
|
public void Update_NaN_UsesLastValidValue()
|
|
{
|
|
var vroc = new Vroc(period: 3);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Add valid bars
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Add bar with NaN volume
|
|
var nanBar = new TBar(now.AddMinutes(5), 100, 100, 100, 100, double.NaN);
|
|
var result = vroc.Update(nanBar, isNew: true);
|
|
|
|
Assert.True(double.IsFinite(result.Value), "Result should be finite after NaN input");
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_Infinity_UsesLastValidValue()
|
|
{
|
|
var vroc = new Vroc(period: 3);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Add valid bars
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Add bar with Infinity volume
|
|
var infBar = new TBar(now.AddMinutes(5), 100, 100, 100, 100, double.PositiveInfinity);
|
|
var result = vroc.Update(infBar, isNew: true);
|
|
|
|
Assert.True(double.IsFinite(result.Value), "Result should be finite after Infinity input");
|
|
}
|
|
|
|
[Fact]
|
|
public void Update_NegativeVolume_UsesLastValidValue()
|
|
{
|
|
var vroc = new Vroc(period: 3);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Add valid bars
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 500);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Add bar with negative volume
|
|
var negBar = new TBar(now.AddMinutes(5), 100, 100, 100, 100, -100);
|
|
var result = vroc.Update(negBar, isNew: true);
|
|
|
|
Assert.True(double.IsFinite(result.Value), "Result should be finite after negative volume input");
|
|
}
|
|
|
|
[Fact]
|
|
public void BatchUpdate_WithNaN_Safe()
|
|
{
|
|
var vroc = new Vroc();
|
|
var bars = new TBarSeries();
|
|
var now = DateTime.UtcNow;
|
|
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
double volume = i == 10 ? double.NaN : 500 + i;
|
|
bars.Add(new TBar(now.AddMinutes(i), 100, 100, 100, 100, volume));
|
|
}
|
|
|
|
var result = vroc.Update(bars);
|
|
|
|
Assert.Equal(20, result.Count);
|
|
foreach (var val in result.Values)
|
|
{
|
|
Assert.True(double.IsFinite(val), "All values should be finite");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Consistency Tests
|
|
|
|
[Fact]
|
|
public void BatchCalc_EqualsStreaming()
|
|
{
|
|
var vroc = new Vroc(period: 12, usePercent: true);
|
|
|
|
// Streaming
|
|
var streamingResults = new List<double>();
|
|
for (int i = 0; i < _bars.Count; i++)
|
|
{
|
|
var result = vroc.Update(_bars[i], isNew: true);
|
|
streamingResults.Add(result.Value);
|
|
}
|
|
|
|
// Batch
|
|
var batchResult = Vroc.Batch(_bars, period: 12, usePercent: true);
|
|
|
|
Assert.Equal(streamingResults.Count, batchResult.Count);
|
|
for (int i = 0; i < streamingResults.Count; i++)
|
|
{
|
|
Assert.Equal(streamingResults[i], batchResult.Values[i], Tolerance);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void SpanCalc_EqualsStreaming()
|
|
{
|
|
var vroc = new Vroc(period: 12, usePercent: true);
|
|
|
|
// Streaming
|
|
var streamingResults = new List<double>();
|
|
for (int i = 0; i < _bars.Count; i++)
|
|
{
|
|
var result = vroc.Update(_bars[i], isNew: true);
|
|
streamingResults.Add(result.Value);
|
|
}
|
|
|
|
// Span - pass arrays directly (implicit span conversion)
|
|
var volume = _bars.Volume.Values.ToArray();
|
|
var output = new double[_bars.Count];
|
|
Vroc.Batch(volume, output, period: 12, usePercent: true);
|
|
|
|
for (int i = 0; i < streamingResults.Count; i++)
|
|
{
|
|
Assert.Equal(streamingResults[i], output[i], Tolerance);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void BatchUpdate_EqualsStreaming()
|
|
{
|
|
var vrocStream = new Vroc(period: 12, usePercent: true);
|
|
var vrocBatch = new Vroc(period: 12, usePercent: true);
|
|
|
|
// Streaming
|
|
for (int i = 0; i < _bars.Count; i++)
|
|
{
|
|
vrocStream.Update(_bars[i], isNew: true);
|
|
}
|
|
|
|
// Batch
|
|
var batchResult = vrocBatch.Update(_bars);
|
|
|
|
Assert.Equal(vrocStream.Last.Value, batchResult.Values[^1], Tolerance);
|
|
}
|
|
|
|
[Fact]
|
|
public void PointMode_EqualsStreaming()
|
|
{
|
|
var vroc = new Vroc(period: 12, usePercent: false);
|
|
|
|
// Streaming
|
|
var streamingResults = new List<double>();
|
|
for (int i = 0; i < _bars.Count; i++)
|
|
{
|
|
var result = vroc.Update(_bars[i], isNew: true);
|
|
streamingResults.Add(result.Value);
|
|
}
|
|
|
|
// Span - pass arrays directly (implicit span conversion)
|
|
var volume = _bars.Volume.Values.ToArray();
|
|
var output = new double[_bars.Count];
|
|
Vroc.Batch(volume, output, period: 12, usePercent: false);
|
|
|
|
for (int i = 0; i < streamingResults.Count; i++)
|
|
{
|
|
Assert.Equal(streamingResults[i], output[i], Tolerance);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Span API Tests
|
|
|
|
[Fact]
|
|
public void Calculate_Span_ValidatesLengths()
|
|
{
|
|
var volume = new double[100];
|
|
var output = new double[50]; // Wrong length
|
|
|
|
ArgumentException? caught = null;
|
|
try
|
|
{
|
|
Vroc.Batch(volume, output, period: 12, usePercent: true);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
caught = ex;
|
|
}
|
|
|
|
Assert.NotNull(caught);
|
|
Assert.Equal("output", caught.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Calculate_Span_ValidatesPeriod()
|
|
{
|
|
var volume = new double[100];
|
|
var output = new double[100];
|
|
|
|
ArgumentException? caught = null;
|
|
try
|
|
{
|
|
Vroc.Batch(volume, output, period: 0, usePercent: true);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
caught = ex;
|
|
}
|
|
|
|
Assert.NotNull(caught);
|
|
Assert.Equal("period", caught.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void Calculate_Span_HandlesEmpty()
|
|
{
|
|
double[] volumeArr = [];
|
|
double[] outputArr = [];
|
|
|
|
// Should not throw
|
|
Vroc.Batch(volumeArr, outputArr, period: 12, usePercent: true);
|
|
|
|
Assert.Empty(outputArr);
|
|
}
|
|
|
|
[Fact]
|
|
public void Calculate_Span_HandlesNaN()
|
|
{
|
|
var volume = new double[20];
|
|
var output = new double[20];
|
|
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
volume[i] = i == 10 ? double.NaN : 500 + i;
|
|
}
|
|
|
|
Vroc.Batch(volume, output, period: 5, usePercent: true);
|
|
|
|
foreach (var val in output)
|
|
{
|
|
Assert.True(double.IsFinite(val), "All values should be finite");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Calculate_Span_LargeData_NoStackOverflow()
|
|
{
|
|
var volume = new double[10000];
|
|
var output = new double[10000];
|
|
|
|
for (int i = 0; i < 10000; i++)
|
|
{
|
|
volume[i] = 500 + (i % 100);
|
|
}
|
|
|
|
// Should not throw stack overflow
|
|
Vroc.Batch(volume, output, period: 100, usePercent: true);
|
|
|
|
Assert.True(double.IsFinite(output[^1]));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event Tests
|
|
|
|
[Fact]
|
|
public void Pub_FiresOnUpdate()
|
|
{
|
|
var vroc = new Vroc();
|
|
var eventFired = false;
|
|
|
|
vroc.Pub += (object? sender, in TValueEventArgs args) => { eventFired = true; };
|
|
vroc.Update(_bars[0]);
|
|
|
|
Assert.True(eventFired);
|
|
}
|
|
|
|
[Fact]
|
|
public void Pub_ChainingWorks()
|
|
{
|
|
var vroc = new Vroc();
|
|
var receivedValues = new List<double>();
|
|
|
|
vroc.Pub += (object? sender, in TValueEventArgs args) => { receivedValues.Add(args.Value.Value); };
|
|
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
vroc.Update(_bars[i], isNew: true);
|
|
}
|
|
|
|
Assert.Equal(20, receivedValues.Count);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TValue Input Tests
|
|
|
|
[Fact]
|
|
public void Update_TValue_PreservesLastValue()
|
|
{
|
|
var vroc = new Vroc();
|
|
var now = DateTime.UtcNow;
|
|
|
|
// First update with bar to set a value
|
|
var bar = new TBar(now, 100, 100, 100, 100, 500);
|
|
vroc.Update(bar, isNew: true);
|
|
var lastValue = vroc.Last.Value;
|
|
|
|
// TValue update should preserve last value (VROC requires volume)
|
|
var tval = new TValue(now.AddMinutes(1), 200);
|
|
var result = vroc.Update(tval, isNew: true);
|
|
|
|
Assert.Equal(lastValue, result.Value, Tolerance);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Zero Historical Volume Tests
|
|
|
|
[Fact]
|
|
public void Update_ZeroHistoricalVolume_ReturnsZeroPercent()
|
|
{
|
|
var vroc = new Vroc(period: 3, usePercent: true);
|
|
var now = DateTime.UtcNow;
|
|
|
|
// Initial volumes of 0
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
var bar = new TBar(now.AddMinutes(i), 100, 100, 100, 100, 0);
|
|
vroc.Update(bar, isNew: true);
|
|
}
|
|
|
|
// Non-zero volume
|
|
var newBar = new TBar(now.AddMinutes(3), 100, 100, 100, 100, 1000);
|
|
var result = vroc.Update(newBar, isNew: true);
|
|
|
|
// Division by zero protection should return 0
|
|
Assert.Equal(0.0, result.Value, Tolerance);
|
|
}
|
|
|
|
#endregion
|
|
}
|