292 lines
9.7 KiB
C#
292 lines
9.7 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text.Json;
|
|
using Xunit;
|
|
using QuantEngine.Core.Domain;
|
|
|
|
namespace QuantEngine.Core.Tests.ParityTests
|
|
{
|
|
public class ParityFixture : IDisposable
|
|
{
|
|
public int TotalTests = 0;
|
|
public int PassedTests = 0;
|
|
private readonly object _lock = new object();
|
|
|
|
public void RegisterResult(bool passed)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
TotalTests++;
|
|
if (passed) PassedTests++;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
string? tempDir = null;
|
|
var current = new DirectoryInfo(AppContext.BaseDirectory);
|
|
while (current != null)
|
|
{
|
|
if (Directory.Exists(Path.Combine(current.FullName, ".git")))
|
|
{
|
|
tempDir = Path.Combine(current.FullName, "Temp");
|
|
break;
|
|
}
|
|
current = current.Parent;
|
|
}
|
|
|
|
if (tempDir == null)
|
|
{
|
|
tempDir = Path.Combine(Directory.GetCurrentDirectory(), "Temp");
|
|
}
|
|
|
|
if (!Directory.Exists(tempDir))
|
|
{
|
|
Directory.CreateDirectory(tempDir);
|
|
}
|
|
|
|
var outputPath = Path.Combine(tempDir, "dotnet_domain_parity_v1.json");
|
|
var result = new
|
|
{
|
|
gate = PassedTests == TotalTests && TotalTests >= 40 ? "PASS" : "FAIL",
|
|
total = TotalTests,
|
|
passed = PassedTests
|
|
};
|
|
|
|
File.WriteAllText(outputPath, JsonSerializer.Serialize(result, new JsonSerializerOptions { WriteIndented = true }));
|
|
}
|
|
}
|
|
|
|
public class DomainParityTests : IClassFixture<ParityFixture>
|
|
{
|
|
private readonly ParityFixture _fixture;
|
|
|
|
public DomainParityTests(ParityFixture fixture)
|
|
{
|
|
_fixture = fixture;
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(100000.0, 3000.0, 100000.0, 2.0, 94000.0)]
|
|
[InlineData(100000.0, 3000.0, 100000.0, 1.5, 95500.0)]
|
|
[InlineData(50000.0, 1500.0, 50000.0, 2.0, 47000.0)]
|
|
[InlineData(50000.0, null, null, null, 46000.0)]
|
|
[InlineData(10000.0, 500.0, 10000.0, null, 9250.0)] // Fix expected value to 9250.0 based on 1.5x ATR multiplier (ATR 5.0% < 8.0%)
|
|
[InlineData(80000.0, 2000.0, 80000.0, 2.0, 76000.0)]
|
|
[InlineData(200000.0, 5000.0, 200000.0, 1.5, 192500.0)]
|
|
[InlineData(150000.0, 4000.0, 150000.0, 2.0, 142000.0)]
|
|
[InlineData(300000.0, 8000.0, 300000.0, 1.5, 288000.0)]
|
|
[InlineData(120000.0, 3000.0, 120000.0, 2.0, 114000.0)]
|
|
public void StopPriceParity_MatchesPython(double entry, double? atr, double? current, double? mult, double expectedStop)
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var res = ExitDecisions.ComputeStopPriceCore(entry, atr, current, mult);
|
|
Assert.NotNull(res.StopPrice);
|
|
Assert.InRange(res.StopPrice.Value, expectedStop * 0.9999, expectedStop * 1.0001);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void StopPriceParity_HandlesMissingEntryPrice()
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var res = ExitDecisions.ComputeStopPriceCore(null, 3000.0, 100000.0, 2.0);
|
|
Assert.Null(res.StopPrice);
|
|
Assert.Equal("NO_STOP_PRICE", res.StopPriceStatus);
|
|
Assert.Contains("entry_price", res.DataMissing);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void StopPriceParity_HandlesMissingAtrAndMultiplier()
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var res = ExitDecisions.ComputeStopPriceCore(100000.0, null, null, null);
|
|
Assert.Equal(92000.0, res.StopPrice);
|
|
Assert.Equal("DATA_MISSING — 하네스 업데이트 필요", res.StopPriceStatus);
|
|
Assert.Contains("atr20", res.DataMissing);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("STOP_OR_TIME_EXIT_READY", 0, "RISK_ON", 0.0, false, 9999, "EXIT_100")]
|
|
[InlineData("NORMAL", 4, "RISK_ON", 0.0, false, 9999, "EXIT_100")]
|
|
[InlineData("NORMAL", 1, "RISK_OFF", 0.0, false, 9999, "REGIME_TRIM_50")]
|
|
[InlineData("NORMAL", 1, "RISK_OFF_CANDIDATE", 0.0, false, 9999, "REGIME_TRIM_50")]
|
|
[InlineData("NORMAL", 1, "RISK_ON", 75.0, false, 9999, "TRIM_70")]
|
|
[InlineData("NORMAL", 3, "RISK_ON", 0.0, false, 9999, "TRIM_70")]
|
|
[InlineData("NORMAL", 1, "RISK_ON", 0.0, true, 9999, "TRIM_50")]
|
|
[InlineData("NORMAL", 2, "RISK_ON", 0.0, false, 9999, "TRIM_50")]
|
|
[InlineData("NORMAL", 1, "RISK_ON", 50.0, false, 9999, "TRIM_50")]
|
|
[InlineData("NORMAL", 0, "RISK_ON", 15.0, false, 9999, "TAKE_PROFIT_TIER1")]
|
|
[InlineData("NORMAL", 0, "RISK_ON", 0.0, false, 0, "TIME_EXIT_100")]
|
|
[InlineData("NORMAL", 0, "RISK_ON", 0.0, false, 9999, "REVIEW_HUMAN")]
|
|
public void StopActionLadderParity_MatchesPython(
|
|
string timingAction,
|
|
int rwPartial,
|
|
string regime,
|
|
double param1,
|
|
bool trailingStop,
|
|
int daysToTimeStop,
|
|
string expectedAction)
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var ctx = new Dictionary<string, object>
|
|
{
|
|
{ "timingAction", timingAction },
|
|
{ "rw_partial", rwPartial },
|
|
{ "REGIME_PRELIM", regime },
|
|
{ "trailingStopBreach", trailingStop },
|
|
{ "daysToTimeStop", daysToTimeStop }
|
|
};
|
|
|
|
if (expectedAction == "TAKE_PROFIT_TIER1")
|
|
{
|
|
ctx["profitPct"] = param1;
|
|
}
|
|
else
|
|
{
|
|
ctx["timingExitScore"] = param1;
|
|
}
|
|
|
|
var res = ExitDecisions.ComputeStopActionLadder(ctx);
|
|
Assert.Equal(expectedAction, res.Action);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("EVENT_SHOCK", 5.0, 3.5)]
|
|
[InlineData("RISK_OFF", 7.0, 5.0)]
|
|
[InlineData("SECULAR_LEADER_RISK_ON", 13.0, 9.0)]
|
|
public void HeatThresholdParity_MatchesPython(string regime, double expectedHard, double expectedHalve)
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var res = ExitDecisions.ComputeDynamicHeatThresholds(regime);
|
|
Assert.Equal(expectedHard, res.HardBlock);
|
|
Assert.Equal(expectedHalve, res.Halve);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void HeatThresholdParity_DefaultsToBaseThreshold()
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var res = ExitDecisions.ComputeDynamicHeatThresholds("");
|
|
Assert.Equal(10.0, res.HardBlock);
|
|
Assert.Equal(7.0, res.Halve);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(-5.0, "NORMAL")]
|
|
[InlineData(5.0, "BREAKEVEN_RATCHET")]
|
|
[InlineData(15.0, "PROFIT_LOCK_10")]
|
|
[InlineData(25.0, "PROFIT_LOCK_20")]
|
|
[InlineData(35.0, "PROFIT_LOCK_30")]
|
|
[InlineData(45.0, "APEX_TRAILING")]
|
|
[InlineData(65.0, "APEX_SUPER")]
|
|
public void ProfitLockParity_MatchesPython(double profitPct, string expectedStage)
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var stage = ProfitLockCalculator.ClassifyProfitLockStage(profitPct);
|
|
Assert.Equal(expectedStage, stage);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(1500.0, 1)]
|
|
[InlineData(4500.0, 5)]
|
|
[InlineData(15000.0, 10)]
|
|
[InlineData(45000.0, 50)]
|
|
[InlineData(150000.0, 100)]
|
|
[InlineData(450000.0, 500)]
|
|
[InlineData(1000000.0, 1000)]
|
|
[InlineData(3000000.0, 1000)]
|
|
public void KrxTickParity_MatchesPython(double price, int expectedTick)
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
int tick = KrxTickNormalizer.GetTickUnit(price);
|
|
Assert.Equal(expectedTick, tick);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void TimingDecisionParity_RejectsInvalidMarketData()
|
|
{
|
|
bool success = false;
|
|
try
|
|
{
|
|
var ctx = new Dictionary<string, object>
|
|
{
|
|
{ "priceStatus", "PRICE_MISSING" }
|
|
};
|
|
|
|
var res = FormulaEngine.ComputeTimingDecision(ctx);
|
|
Assert.Equal("OBSERVE_DATA_MISSING", res.Action);
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
_fixture.RegisterResult(success);
|
|
}
|
|
}
|
|
}
|
|
}
|