1412 lines
66 KiB
C#
1412 lines
66 KiB
C#
using Newtonsoft.Json;
|
||
using YLErp.DBModels;
|
||
using YLErp.DBModels.Enums;
|
||
using YLErp.Models;
|
||
|
||
namespace YLErp.Modules.SwapModule
|
||
{
|
||
/// <summary>
|
||
/// 互换利息计算单元测试
|
||
/// ================================================================
|
||
/// 测试口径说明：
|
||
/// "11" = 算头算尾（含起息日和到期日）
|
||
/// "10" = 算头不算尾（含起息日，不含到期日）
|
||
/// "01" = 不算头算尾（不含起息日，含到期日）
|
||
/// "00" = 不算头不算尾（不含起息日也不含到期日）
|
||
/// 不算头不算尾暂时测试不通过
|
||
/// 统一测试数据：
|
||
/// - Principal=1000, FixedRate=1.00%, AnnualDays=365
|
||
/// - ResetPeriod=3天, InterestRule=-1(前一营业日), InterestRule=0(当前营业日)
|
||
/// - FR007@2026-04-27=0.10%, FR007@2026-04-30=0.20%
|
||
/// - StartDate=2026-04-28, TradeDate=2026-04-27
|
||
/// ================================================================
|
||
/// </summary>
|
||
[TestClass]
|
||
public class GetInterestsUnitTest
|
||
{
|
||
#region 内部类：浮动利率模拟服务
|
||
|
||
/// <summary>
|
||
/// StubSwapDealService - 模拟浮动利率获取
|
||
/// 用于单元测试中预置FR007价格，避免依赖外部数据源
|
||
/// </summary>
|
||
private sealed class StubSwapDealService : SwapDealService
|
||
{
|
||
private readonly IReadOnlyDictionary<DateTime, double> _floatRates;
|
||
|
||
public StubSwapDealService(OptUserInfo optUser, IReadOnlyDictionary<DateTime, double> floatRates) : base(optUser)
|
||
{
|
||
_floatRates = floatRates;
|
||
}
|
||
|
||
protected override bool TryGetFloatRate(DateTime valueDate, string underlyingCode, out double rate)
|
||
{
|
||
if (!string.Equals(underlyingCode, "FR007", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
rate = 0;
|
||
return false;
|
||
}
|
||
|
||
if (_floatRates.TryGetValue(valueDate.Date, out rate))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
rate = 0;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 测试常量与共享变量
|
||
|
||
private const decimal Principal = 1000m; // 本金：1000
|
||
private const decimal FixedRate = 0.01m; // 固定利率：1.00%
|
||
private const int AnnualDays = 365; // 年化天数
|
||
private const int ResetPeriod = 3; // 重置周期：3天
|
||
private const int InterestRule_Pre = -1; // 前一营业日规则
|
||
private const int InterestRule_Cur = 0; // 当前营业日规则
|
||
|
||
private static readonly DateTime TradeDate = new(2026, 4, 27); // 成交日
|
||
private static readonly DateTime StartDate = new(2026, 4, 28); // 起息日（开始计息日）
|
||
private static readonly DateTime ExerciseDate = new(2027, 4, 27); // 到期日
|
||
|
||
private SwapDealService _service;
|
||
private IReadOnlyDictionary<DateTime, double> _floatRates;
|
||
|
||
[TestInitialize]
|
||
public void Init()
|
||
{
|
||
// 预置FR007价格数据
|
||
_floatRates = new Dictionary<DateTime, double>
|
||
{
|
||
[new DateTime(2026, 4, 27)] = 0.001, // FR007@2026-04-27 = 0.10%
|
||
[new DateTime(2026, 4, 28)] = 0.001, // FR007@2026-04-28 = 0.10% (新增)
|
||
[new DateTime(2026, 4, 29)] = 0.001, // FR007@2026-04-29 = 0.10%
|
||
[new DateTime(2026, 4, 30)] = 0.002, // FR007@2026-04-30 = 0.20%
|
||
[new DateTime(2026, 5, 6)] = 0.002, // FR007@2026-05-06 = 0.20%
|
||
// 到期日测试用例需要的利率数据（2027年）
|
||
[new DateTime(2027, 4, 23)] = 0.001, // FR007@2027-04-23 = 0.10%（2027-04-26的前一工作日）
|
||
[new DateTime(2027, 4, 24)] = 0.001, // FR007@2027-04-24 = 0.10%（周末）
|
||
[new DateTime(2027, 4, 25)] = 0.001, // FR007@2027-04-25 = 0.10%（周末）
|
||
[new DateTime(2027, 4, 26)] = 0.001, // FR007@2027-04-26 = 0.10%
|
||
[new DateTime(2027, 4, 27)] = 0.001 // FR007@2027-04-27 = 0.10%（到期日）
|
||
};
|
||
|
||
_service = new StubSwapDealService(
|
||
new OptUserInfo(0, nameof(GetInterestsUnitTest), OptUserFrom.UnitTest),
|
||
_floatRates);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 测试数据构建器
|
||
|
||
/// <summary>
|
||
/// 创建测试用交易对象
|
||
/// </summary>
|
||
/// <param name="interestCalcMode">计息口径："11"/"10"/"01"/"00"</param>
|
||
/// <param name="interestRule">取率规则：-1=前一营业日，0=当前营业日</param>
|
||
private static trade CreateTrade(string interestCalcMode, int interestRule = InterestRule_Pre)
|
||
{
|
||
var extend = new trade_extend
|
||
{
|
||
TradeId = 1,
|
||
ExtendJson = JsonConvert.SerializeObject(new TradeExtendJson
|
||
{
|
||
AnnualDays = AnnualDays,
|
||
InterestCalcMode = interestCalcMode,
|
||
SettlementRules = interestRule
|
||
})
|
||
};
|
||
|
||
return new trade
|
||
{
|
||
id = 1,
|
||
TradeNumber = "UT-SWAP-INT-001",
|
||
ClientId = 999998,
|
||
TradeType = "收益互换",
|
||
TradeDate = TradeDate,
|
||
StartDate = StartDate,
|
||
ExerciseDate = ExerciseDate,
|
||
TradeStatus = "确认成交",
|
||
ValidState = "Valid",
|
||
trade_extend = extend
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建测试用持仓对象
|
||
/// </summary>
|
||
/// <param name="interestCalcMode">计息口径</param>
|
||
/// <param name="interestRule">取率规则</param>
|
||
private static swap_position CreateInterestPosition(string interestCalcMode, int interestRule = InterestRule_Pre)
|
||
{
|
||
var intervalModels = new List<IntervalModel>
|
||
{
|
||
new IntervalModel
|
||
{
|
||
Date = ExerciseDate,
|
||
Rate = FixedRate,
|
||
Settlement = 0
|
||
}
|
||
};
|
||
|
||
return new swap_position
|
||
{
|
||
id = 1001,
|
||
SwapTradeId = 1,
|
||
PositionType = (int)PositionTypeFlag.Unknown,
|
||
InterestDirection = (int)SwapDirectionEnum.收取,
|
||
InterestMode = (int)InterestModeEnum.标的期初全价,
|
||
InterestRateDefault = FixedRate,
|
||
InterestPrincipalFix = Principal,
|
||
PosiStartDate = StartDate,
|
||
PosiMatuirityDate = ExerciseDate,
|
||
IsInitial = true,
|
||
Invalid = false,
|
||
InterestType = (int)InterestTypeEnum.单利,
|
||
IsAnnualized = true,
|
||
interest_rest_days = ResetPeriod,
|
||
interest_rule = interestRule,
|
||
FloatRateUnderlyingCode = "FR007",
|
||
InterestSwapInterval = JsonConvert.SerializeObject(intervalModels)
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建日终持仓记录（EOD归档数据）
|
||
/// </summary>
|
||
private static eod_swap_position CreateEodPosition(DateTime valueDate, decimal tdPrincipal, decimal floatRate, decimal interestSum)
|
||
{
|
||
return new eod_swap_position
|
||
{
|
||
id = 1,
|
||
SwapTradeId = 1,
|
||
PositionId = 1001,
|
||
ValueDate = valueDate,
|
||
ClientId = 999998,
|
||
FloatRate = floatRate,
|
||
TdInterestPrincipal = tdPrincipal,
|
||
PosiNotionalValue = tdPrincipal,
|
||
InterestProfitSum = interestSum
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 计算期望利息金额
|
||
/// 公式：本金 × (固定利率 + 浮动利率) × 计息天数 ÷ 年化天数
|
||
/// </summary>
|
||
private static decimal ExpectedInterest(int days, decimal fixedRate, decimal floatRate, decimal principal)
|
||
{
|
||
var yearlyRate = fixedRate + floatRate;
|
||
var interest = principal * yearlyRate * days / AnnualDays;
|
||
return Math.Round(interest, ConsGlobal.PriceRound, MidpointRounding.AwayFromZero);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 通用的GetInterests调用方法
|
||
|
||
/// <summary>
|
||
/// 通用平仓计算（不含eodPositions）
|
||
/// </summary>
|
||
private swap_flow_event CalcUnwind(string interestCalcMode, DateTime valueDate, DateTime unwindDate,
|
||
decimal closePercent, int interestRule = InterestRule_Pre)
|
||
{
|
||
return CalcUnwind(interestCalcMode, valueDate, unwindDate, closePercent,
|
||
new List<eod_swap_position>(), interestRule);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 通用平仓计算（含eodPositions）
|
||
/// </summary>
|
||
private swap_flow_event CalcUnwind(string interestCalcMode, DateTime valueDate, DateTime unwindDate,
|
||
decimal closePercent, List<eod_swap_position> eodPositions, int interestRule = InterestRule_Pre)
|
||
{
|
||
var td = CreateTrade(interestCalcMode, interestRule);
|
||
var position = CreateInterestPosition(interestCalcMode, interestRule);
|
||
|
||
var interests = _service.GetInterests(
|
||
td, td.trade_extend,
|
||
valueDate, unwindDate,
|
||
eodPositions,
|
||
new List<swap_position> { position },
|
||
Principal, 0, 0,
|
||
Principal, closePercent,
|
||
(int)SwapEventTypeEnum.平仓,
|
||
false, false, 0, Principal,
|
||
false,
|
||
false);
|
||
|
||
Assert.AreEqual(1, interests.Count);
|
||
return interests[0];
|
||
}
|
||
|
||
/// <summary>
|
||
/// 通用收盘计算
|
||
/// settment=true 表示收盘场景
|
||
/// </summary>
|
||
private swap_flow_event CalcEod(string interestCalcMode, DateTime valueDate,
|
||
List<eod_swap_position> eodPositions, int interestRule = InterestRule_Pre)
|
||
{
|
||
var td = CreateTrade(interestCalcMode, interestRule);
|
||
var position = CreateInterestPosition(interestCalcMode, interestRule);
|
||
|
||
var interests = _service.GetInterests(
|
||
td, td.trade_extend,
|
||
valueDate, valueDate,
|
||
eodPositions,
|
||
new List<swap_position> { position },
|
||
Principal, 0, 0,
|
||
Principal, 1m,
|
||
(int)SwapEventTypeEnum.平仓,
|
||
false, false, 0, Principal,
|
||
false,
|
||
true); // settment=true 表示收盘
|
||
|
||
Assert.AreEqual(1, interests.Count);
|
||
return interests[0];
|
||
}
|
||
|
||
/// <summary>
|
||
/// 通用自动互换计算
|
||
/// 使用SwapEventTypeEnum.自动互换事件类型
|
||
/// </summary>
|
||
private swap_flow_event CalcAutoSwap(string interestCalcMode, DateTime valueDate,
|
||
List<eod_swap_position> eodPositions, decimal closePercent = 1m, int interestRule = InterestRule_Pre)
|
||
{
|
||
var td = CreateTrade(interestCalcMode, interestRule);
|
||
var position = CreateInterestPosition(interestCalcMode, interestRule);
|
||
|
||
var interests = _service.GetInterests(
|
||
td, td.trade_extend,
|
||
valueDate, valueDate,
|
||
eodPositions,
|
||
new List<swap_position> { position },
|
||
Principal, 0, 0,
|
||
Principal, closePercent,
|
||
(int)SwapEventTypeEnum.自动互换,
|
||
false, false, 0, Principal,
|
||
false,
|
||
false);
|
||
|
||
Assert.AreEqual(1, interests.Count);
|
||
return interests[0];
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 场景1：算头算尾 (InterestCalcMode="11")
|
||
#region 计息区间说明：
|
||
/// 11_001: 首日(StartDate=4/28)平仓 → S=4/28, E=4/28 → 1天
|
||
/// 11_002: 次日(4/29)平仓 → S=4/28, E=4/29 → 2天
|
||
/// 11_003: 次日(4/29)平仓50% → S=4/28, E=4/29 → 2天×50%
|
||
/// 11_004: 跨周期(5/6)平仓 → S=4/28, E=5/6 → 8天(分段取率)
|
||
/// 11_EOD_001: 首日(4/28)收盘 → 1天
|
||
/// 11_EOD_002: 4/28已收盘 → 4/29平仓 → S=4/29, E=4/29 → 1天
|
||
#endregion
|
||
/// ================================================================ */
|
||
|
||
/// <summary>
|
||
/// [11_001] 算头算尾 - 首日起息日平仓
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日StartDate）盘中执行全平
|
||
/// 前置：无上一日EOD持仓（首次操作）
|
||
/// 操作：valueDate=2026-04-28，执行"全平"（closePercent=100%）
|
||
/// 口径：算头算尾，计息区间 S=4/28, E=4/28
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_PRE_001()
|
||
{
|
||
var interest = CalcUnwind("11", new DateTime(2026, 4, 28), new DateTime(2026, 4, 28), 1m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [11_002] 算头算尾 - 次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行全平
|
||
/// 前置：无上一日EOD持仓
|
||
/// 操作：valueDate=2026-04-29，执行"全平"
|
||
/// 口径：算头算尾，计息区间 S=4/28, E=4/29
|
||
/// 期望：计息天数=2天，利息=2*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_PRE_002()
|
||
{
|
||
var interest = CalcUnwind("11", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
var expected = ExpectedInterest(2, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [11_003] 算头算尾 - 次日平仓50%
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行平仓50%
|
||
/// 操作：valueDate=2026-04-29，执行"平仓50%"（closePercent=50%）
|
||
/// 口径：算头算尾，计息区间 S=4/28, E=4/29
|
||
/// 期望：计息天数=2天，利息=0.5*2*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_PRE_003()
|
||
{
|
||
var interest = CalcUnwind("11", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 0.5m);
|
||
var expected = ExpectedInterest(2, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [11_004] 算头算尾 - 跨重置周期全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 未平仓；2026-05-06 跨周期全平
|
||
/// 背景：ResetPeriod=3天，4/28→4/30为第一周期，5/1→5/6为第二周期
|
||
/// 操作：valueDate=2026-05-06，执行"全平"
|
||
/// 取率：跨周期分段取率
|
||
/// - 第一段(4/28-4/30): 3天×FR007@4/27(0.10%)
|
||
/// - 第二段(5/1-5/6): 6天×FR007@4/30(0.20%)
|
||
/// 口径：算头算尾，计息区间 S=4/28, E=5/6
|
||
/// 期望：分段计算利息
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_PRE_004()
|
||
{
|
||
var interest = CalcUnwind("11", new DateTime(2026, 5, 6), new DateTime(2026, 5, 6), 1m);
|
||
// 预期分段计算：3天@0.10% + 6天@0.20%
|
||
var expected = Math.Round(
|
||
ExpectedInterest(3, FixedRate, 0.001m, Principal) +
|
||
ExpectedInterest(6, FixedRate, 0.002m, Principal),
|
||
ConsGlobal.PriceRound, MidpointRounding.AwayFromZero);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [11_EOD_001] 算头算尾 - 首日收盘归档
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日）执行收盘EOD归档
|
||
/// 前置：无上一日EOD持仓（首次收盘）
|
||
/// 操作：执行 2026-04-28 收盘归档
|
||
/// 口径：算头算尾，计息区间 S=4/28, E=4/28
|
||
/// 期望：当日收盘利息=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_EOD_001()
|
||
{
|
||
var interest = CalcEod("11", new DateTime(2026, 4, 28), new List<eod_swap_position>());
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [11_EOD_002] 算头算尾 - 前日已收盘，次日平仓
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘归档；2026-04-29 盘中执行全平
|
||
/// 前置：存在4/28的EOD持仓记录（待实现利息=1天利息）
|
||
/// 操作：valueDate=2026-04-29，执行"全平"
|
||
/// 口径：算头算尾
|
||
/// 期望：总利息=历史待实现利息+当期利息=1天(4/28)+1天(4/29)=2天
|
||
/// 利息=2*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_EOD_002()
|
||
{
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal))
|
||
};
|
||
var interest = CalcUnwind("11", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m, eodPositions);
|
||
// 平仓利息 = 历史待实现利息(4/28=1天) + 当期利息(4/29=1天) = 2天
|
||
var expected = ExpectedInterest(2, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 场景2：算头不算尾 (InterestCalcMode="10") - 当前测试重点
|
||
#region 计息区间说明：
|
||
/// 10_001: 首日(4/28)平仓 → S=4/28, E=4/27 → 0天
|
||
/// 10_002: 次日(4/29)全平 → S=4/28, E=4/28 → 1天
|
||
/// 10_003: 次日(4/29)半平 → 1天×50%
|
||
/// 10_004: 次日(4/29)全平后收盘 → 全平利息+收盘待实现=0
|
||
/// 10_005: 第3日(4/30)全平 → S=4/28, E=4/29 → 2天
|
||
/// 10_006: 第3日(4/30)半平 → 2天×50%
|
||
/// 10_007: 次日(4/29)半平 + 第3日(4/30)收盘 → 剩余50%×1天
|
||
/// 10_008: 第3日(4/30)直接收盘 → 持仓×1天
|
||
/// 10_009: 次日(4/29)自动互换 → 1天
|
||
/// 10_010: 自动互换后次日(4/30)平仓 → 0天
|
||
/// 10_011: 跨周期(5/6)全平 → 分段计息
|
||
/// 10_EOD_001: 首日(4/28)收盘 → 0天(首次)
|
||
/// 10_EOD_002: 4/28收盘 → 4/29全平 → 1天
|
||
/// 10_EOD_003: 4/28收盘 → 4/29半平 → 0.5天
|
||
/// 10_EOD_004: 4/28→4/29连续收盘
|
||
/// 10_EOD_005: 4/28收盘 → 4/30收盘
|
||
#endregion
|
||
/// ================================================================ */
|
||
|
||
#region 2.1 盘中平仓场景
|
||
|
||
/// <summary>
|
||
/// [10_001] 算头不算尾 - 首日起息日平仓
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日StartDate）盘中执行全平
|
||
/// 前置：无上一日EOD持仓
|
||
/// 操作：valueDate=2026-04-28，执行"全平"
|
||
/// 口径：算头不算尾
|
||
/// - 算头：计息开始日 S=4/28（起息日）
|
||
/// - 不算尾：计息结束日 E=4/27（前一日）
|
||
/// - 计息天数 = E - S = 4/27 - 4/28 = -1 → 0天
|
||
/// 期望：计息天数=0天，利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_001()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 28), new DateTime(2026, 4, 28), 1m);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_002] 算头不算尾 - 次日全平（基准场景）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行全平
|
||
/// 前置：无上一日EOD持仓
|
||
/// 操作：valueDate=2026-04-29，执行"全平"
|
||
/// 取率：前一营业日规则 → 取2026-04-27的FR007=0.10%
|
||
/// 口径：算头不算尾
|
||
/// - 算头：S=4/28（起息日）
|
||
/// - 不算尾：E=4/28（操作日前一日）
|
||
/// - 计息天数 = 4/28 - 4/28 = 1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_002()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_003] 算头不算尾 - 次日平仓50%
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行平仓一半
|
||
/// 操作：valueDate=2026-04-29，执行"平仓50%"（closePercent=50%）
|
||
/// 取率：前一营业日规则 → FR007@2026-04-27=0.10%
|
||
/// 口径：算头不算尾，计息天数=1天
|
||
/// 期望：计息天数=1天，利息=0.5*1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_003()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 0.5m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_004] 算头不算尾 - 次日全平后收盘
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中全平；2026-04-29 收盘
|
||
/// 操作：
|
||
/// 1. 2026-04-29 盘中执行"全平" → 计息1天
|
||
/// 2. 2026-04-29 执行收盘归档 → 待实现利息=0
|
||
/// 期望：
|
||
/// - 全平应计利息=1天
|
||
/// - 收盘待实现利息=0（因持仓已不存在）
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_004()
|
||
{
|
||
// 第一步：全平计息
|
||
var unwindInterest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
var expectedUnwind = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expectedUnwind, unwindInterest.InterestAmount);
|
||
|
||
// 第二步：收盘（持仓已不存在，利息=0）
|
||
Console.WriteLine("全平后收盘，待实现利息=0（持仓已不存在）");
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_005] 算头不算尾 - 第3日全平（跨周末）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-30（第3个工作日）盘中全平
|
||
/// 背景：4/28(周二)→4/29(周三)→4/30(周四)，跨2个自然日
|
||
/// 操作：valueDate=2026-04-30，执行"全平"
|
||
/// 取率：按"前一营业日"规则，沿用首个周期取率日 2026-04-27
|
||
/// 口径：算头不算尾
|
||
/// - 算头：S=4/28（起息日）
|
||
/// - 不算尾：E=4/30（操作日前一日）
|
||
/// - 计息天数 = 4/30 - 4/28 = 2天
|
||
/// 实际计算：持仓期间为4/28~4/29(算头不算尾)=2天
|
||
/// 期望：计息天数=2天，利息=2*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_005()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
var expected = ExpectedInterest(2, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_006] 算头不算尾 - 第3日平仓50%（跨周末）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-30 盘中平仓一半
|
||
/// 操作：valueDate=2026-04-30，执行"平仓50%"
|
||
/// 取率：FR007@2026-04-27=0.10%
|
||
/// 口径：算头不算尾，计息天数=2天
|
||
/// 期望：计息天数=2天，利息=0.5*2*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_006()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 0.5m);
|
||
var expected = ExpectedInterest(2, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_007] 算头不算尾 - 次日半平 + 第3日收盘
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中平仓一半；2026-04-30 收盘
|
||
/// 操作：
|
||
/// 1. 2026-04-29 盘中"平仓50%" → 剩余50%持仓
|
||
/// 2. 2026-04-30 执行收盘归档 → 剩余50%持仓计息
|
||
/// 取率：FR007@2026-04-27=0.10%
|
||
/// 口径：算头不算尾
|
||
/// 期望：
|
||
/// - 4/29全平利息=0.5*1*(1.00%+0.10%)*1000/365
|
||
/// - 4/30收盘利息=0.5*1*(1.00%+0.10%)*1000/365（剩余50%计1天）
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_007()
|
||
{
|
||
// 第一步：4月29日平仓50%
|
||
var unwindInterest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 0.5m);
|
||
var expectedUnwind = ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expectedUnwind, unwindInterest.InterestAmount);
|
||
|
||
// 第二步：4月30日收盘（剩余50%持仓计息1天）
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 29), Principal * 0.5m, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m))
|
||
};
|
||
var eodInterest = CalcEod("10", new DateTime(2026, 4, 30), eodPositions);
|
||
var expectedEod = ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expectedEod, eodInterest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_008] 算头不算尾 - 第3日直接收盘（未平仓）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 已收盘归档；2026-04-30 收盘
|
||
/// 背景：持仓期间4/28→4/29已完成收盘归档
|
||
/// 操作：直接执行 2026-04-30 收盘归档
|
||
/// 取率：FR007@2026-04-27=0.10%
|
||
/// 口径：算头不算尾
|
||
/// 期望：2026-04-30 收盘待实现利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_008()
|
||
{
|
||
// 4月29日收盘归档后，4月30日收盘
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 29), Principal, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal))
|
||
};
|
||
var eodInterest = CalcEod("10", new DateTime(2026, 4, 30), eodPositions);
|
||
var expectedEod = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expectedEod, eodInterest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_009] 算头不算尾 - 次日自动互换
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-29 执行"自动互换"
|
||
/// 背景：自动互换是互换交易的一种定期重置操作
|
||
/// 操作：2026-04-29 执行"自动互换"
|
||
/// 取率：FR007@2026-04-27=0.10%
|
||
/// 口径：算头不算尾
|
||
/// 期望：
|
||
/// - 计息天数=1天
|
||
/// - 利息=1*(1.00%+0.10%)*1000/365
|
||
/// - 当日收盘待实现利息=0（持仓已互换）
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_009()
|
||
{
|
||
var interest = CalcAutoSwap("10", new DateTime(2026, 4, 29), new List<eod_swap_position>());
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
Console.WriteLine("自动互换后，当日收盘待实现利息=0");
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_010] 算头不算尾 - 自动互换后次日平仓
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-29 已发生自动互换；2026-04-30 执行"全平/收益结算"
|
||
/// 背景：自动互换已将持仓重置，累计利息清零
|
||
/// 操作：valueDate=2026-04-30，执行"全平"
|
||
/// 口径：算头不算尾
|
||
/// 期望：计息天数=0天，利息=0（持仓已互换）
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_010()
|
||
{
|
||
// 4月29日自动互换后的eodPosition（自动互换后累计利息清零）
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 29), Principal, 0.001m, 0m)
|
||
};
|
||
// 4月30日平仓（持仓已互换，计息天数=0）
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m, eodPositions);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_011] 算头不算尾 - 跨重置周期全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 未平仓；2026-05-06 跨重置周期全平
|
||
/// 背景：
|
||
/// - ResetPeriod=3天
|
||
/// - 第一周期：4/28→4/30，取FR007@4/27=0.10%
|
||
/// - 第二周期：5/1→5/6，取FR007@4/30=0.20%
|
||
/// 操作：
|
||
/// 1. 2026-04-29 收盘归档
|
||
/// 2. 2026-05-06 全平（跨周期）
|
||
/// 口径：算头不算尾
|
||
/// 取率：分段取率
|
||
/// - 4/29收盘利息=1天@0.10%
|
||
/// - 4/30持仓利息=1天@0.10%（第一周期最后一天）
|
||
/// - 5/1~5/5持仓利息=5天@0.20%（第二周期）
|
||
/// 期望：利息 = 4/29收盘 + 4/30持仓 + 5/1~5/5持仓 = oneDay*2 + secondPeriod
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_011()
|
||
{
|
||
// 4月29日收盘归档
|
||
var oneDay = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 29), Principal, 0.001m, oneDay)
|
||
};
|
||
|
||
// 5月6日全平（跨周期）
|
||
var interest = CalcUnwind("10", new DateTime(2026, 5, 6), new DateTime(2026, 5, 6), 1m, eodPositions);
|
||
// 4/30: 1天@0.10%（第一周期），5/1~5/5: 5天@0.20%（第二周期）
|
||
var secondPeriod = ExpectedInterest(5, FixedRate, 0.002m, Principal);
|
||
// 累计利息 = 4/29收盘利息 + 4/30持仓利息(同第一周期) + 5/1~5/5利息
|
||
var expected = Math.Round(oneDay * 2 + secondPeriod,
|
||
ConsGlobal.PriceRound, MidpointRounding.AwayFromZero);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_012] 算头不算尾 - 跨重置周期全平（中间无收盘）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 起息；5/6 全平（中间4/29未收盘）
|
||
/// 背景：
|
||
/// - ResetPeriod=3天
|
||
/// - 第一周期：4/28→4/30，取FR007@4/27=0.10%
|
||
/// - 第二周期：5/1→5/6，取FR007@4/30=0.20%
|
||
/// 操作：4/28起息后，4/29未收盘，直接5/6全平
|
||
/// 口径：算头不算尾
|
||
/// 取率：分段取率
|
||
/// - 4/28~4/30持仓利息=3天@0.10%（第一周期，4/28算头）
|
||
/// - 5/1~5/5持仓利息=5天@0.20%（第二周期）
|
||
/// 期望：利息 = 3天@0.10% + 5天@0.20%
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_012()
|
||
{
|
||
// 4/28起息，无EOD持仓（4/29未收盘）
|
||
var eodPositions = new List<eod_swap_position>();
|
||
|
||
// 5月6日全平（跨周期，4/29未收盘）
|
||
var interest = CalcUnwind("10", new DateTime(2026, 5, 6), new DateTime(2026, 5, 6), 1m, eodPositions);
|
||
// 4/28~4/30: 3天@0.10%（第一周期），5/1~5/5: 5天@0.20%（第二周期）
|
||
var firstPeriod = ExpectedInterest(3, FixedRate, 0.001m, Principal);
|
||
var secondPeriod = ExpectedInterest(5, FixedRate, 0.002m, Principal);
|
||
var expected = Math.Round(firstPeriod + secondPeriod,
|
||
ConsGlobal.PriceRound, MidpointRounding.AwayFromZero);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 2.2 收盘归档场景（文档4.2节 - 组B）
|
||
|
||
/// <summary>
|
||
/// [10_PRE_EOD_001] 算头不算尾 - 首日收盘归档（文档4.2节）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 收盘
|
||
/// 操作：执行 2026-04-28 EOD
|
||
/// 取率日：2026-04-27（FR007=0.10%）
|
||
/// 口径：算头不算尾
|
||
/// 说明：首日收盘，当日计息1天
|
||
/// 期望：当日收盘利息（待实现）=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_EOD_001()
|
||
{
|
||
var interest = CalcEod("10", new DateTime(2026, 4, 28), new List<eod_swap_position>());
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_PRE_EOD_002] 算头不算尾 - 首日收盘，次日全平（文档4.2节）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘；2026-04-29 盘中全平或收益结算
|
||
/// 操作：valueDate=2026-04-29 执行"全平/收益结算"
|
||
/// 取率日：2026-04-27（FR007=0.10%）
|
||
/// 口径：算头不算尾
|
||
/// - 持仓区间：4/28~4/29
|
||
/// - 计息区间：4/29-4/28=1天
|
||
/// 期望：计息天数=1；利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_EOD_002()
|
||
{
|
||
// 4/28收盘，利息=1天
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal))
|
||
};
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m, eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_PRE_EOD_003] 算头不算尾 - 首日收盘，次日平仓50%（文档4.2节）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘；2026-04-29 盘中平仓一半
|
||
/// 操作：valueDate=2026-04-29 执行"平仓50%"
|
||
/// 取率日：2026-04-27（FR007=0.10%）
|
||
/// 口径：算头不算尾
|
||
/// 期望：计息天数=1；利息=0.5*1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_PRE_EOD_003()
|
||
{
|
||
// 4/28收盘，利息=1天
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal))
|
||
};
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 0.5m, eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 2.3 代码额外补充的收盘场景
|
||
|
||
/// <summary>
|
||
/// [10_EOD_001] 算头不算尾 - 首日收盘归档（代码实现版）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日）执行收盘EOD归档
|
||
/// 前置：无上一日EOD持仓（首次收盘）
|
||
/// 操作：执行 2026-04-28 收盘归档
|
||
/// 口径：算头不算尾
|
||
/// 说明：算头，4/28起息日算利息；不算尾指到期日不算
|
||
/// - 算头：S=4/28
|
||
/// - 不算尾：E=4/27（到期日4/28不算）
|
||
/// 期望：当日收盘利息=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_EOD_001()
|
||
{
|
||
var interest = CalcEod("10", new DateTime(2026, 4, 28), new List<eod_swap_position>());
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_EOD_002] 算头不算尾 - 首日收盘，次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘归档；2026-04-29 盘中执行全平
|
||
/// 前置：存在4/28的EOD持仓记录（待实现利息=1天）
|
||
/// 操作：valueDate=2026-04-29，执行"全平"
|
||
/// 口径：算头不算尾
|
||
/// - 算头：4/28起息日算利息
|
||
/// - 不算尾：4/29到期日不算利息
|
||
/// - 历史待实现：4/28=1天
|
||
/// - 当期利息：4/29=0天（不算尾）
|
||
/// 期望：总利息=1天+0天=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_EOD_002()
|
||
{
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal))
|
||
};
|
||
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m, eodPositions);
|
||
// 平仓利息 = 历史待实现(1天) + 当期(0天) = 1天
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_EOD_003] 算头不算尾 - 首日收盘，次日平仓50%
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘归档；2026-04-29 盘中执行平仓一半
|
||
/// 操作：valueDate=2026-04-29，执行"平仓50%"
|
||
/// 口径：算头不算尾，计息天数=1天
|
||
/// 期望：总利息=(历史1天+当期0天)*50%=0.5天，利息=0.5*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_EOD_003()
|
||
{
|
||
// 4/28收盘（算头=1天利息），4/29平仓50%
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m,
|
||
ExpectedInterest(1, FixedRate, 0.001m, Principal))
|
||
};
|
||
|
||
// 平仓50%：总利息=(历史1天+当期0天)*50%=0.5天
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 0.5m, eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_EOD_004] 算头不算尾 - 连续收盘（4/28、4/29）
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 和 2026-04-29 连续两个工作日收盘归档
|
||
/// 操作：
|
||
/// 1. 执行 2026-04-28 收盘归档
|
||
/// 2. 执行 2026-04-29 收盘归档
|
||
/// 口径：算头不算尾
|
||
/// 期望：
|
||
/// - 4/28收盘利息=1天（算头，首日计息）
|
||
/// - 4/29收盘利息=1天 + 4/28累计利息
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_EOD_004()
|
||
{
|
||
// 4月28日收盘（利息=1天，算头）
|
||
var eod1 = CalcEod("10", new DateTime(2026, 4, 28), new List<eod_swap_position>());
|
||
var expected1 = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected1, eod1.InterestAmount);
|
||
|
||
// 4月29日收盘（利息=1天 + 4/28累计利息）
|
||
var eod2 = CalcEod("10", new DateTime(2026, 4, 29), new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m, expected1)
|
||
});
|
||
// 4/29收盘利息 = 4/28累计利息
|
||
var expected2 = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected2, eod2.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_EOD_005] 算头不算尾 - 首日收盘后第3日收盘
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘归档；2026-04-30 执行收盘归档
|
||
/// 背景：4/29(周三)未执行收盘归档
|
||
/// 操作：执行 2026-04-30 收盘归档
|
||
/// 口径：算头不算尾
|
||
/// 期望：4/29收盘利息=1天
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_EOD_005()
|
||
{
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m, 0m)
|
||
};
|
||
|
||
var interest = CalcEod("10", new DateTime(2026, 4, 30), eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_EOD_006] 算头不算尾 - 到期日收盘不算尾
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 起息，2027-04-27 到期（ExerciseDate）
|
||
/// 操作：2027-04-27 执行收盘归档
|
||
/// 口径：算头不算尾（"10"）
|
||
/// - 算头：首日4/28计息
|
||
/// - 不算尾：到期日4/27不计息
|
||
/// 期望：到期日收盘利息=0（到期日不算尾）
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_EOD_006()
|
||
{
|
||
// 2027-04-26 收盘归档产生的 EOD 持仓
|
||
// 假设累计利息为 InterestProfitSum=10
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2027, 4, 26), Principal, 0.001m, 10m)
|
||
};
|
||
|
||
// 到期日 2027-04-27 收盘（不算尾，利息=0）
|
||
var interest = CalcEod("10", new DateTime(2027, 4, 27), eodPositions);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [11_EOD_006] 算头算尾 - 到期日收盘算尾
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 起息，2027-04-27 到期（ExerciseDate）
|
||
/// 操作：2027-04-27 执行收盘归档
|
||
/// 口径：算头算尾（"11"）
|
||
/// - 算头：首日4/28计息
|
||
/// - 算尾：到期日4/27计息
|
||
/// 期望：到期日收盘利息=1天
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_11_EOD_006()
|
||
{
|
||
// 2027-04-26 收盘归档产生的 EOD 持仓
|
||
// 假设累计利息为 InterestProfitSum=10
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2027, 4, 26), Principal, 0.001m, 10m)
|
||
};
|
||
|
||
// 到期日 2027-04-27 收盘（算尾，利息=1天）
|
||
var interest = CalcEod("11", new DateTime(2027, 4, 27), eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 2.3 当前营业日规则（interest_rule=0）
|
||
|
||
/// <summary>
|
||
/// [10_CUR_001] 算头不算尾 + 当前营业日规则 - 次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：算头不算尾（"10"）；interest_rule=0（当前营业日）
|
||
/// 操作：2026-04-28 未收盘；2026-04-29 盘中全平
|
||
/// 前置：提供 FR007@2026-04-29 数据
|
||
/// 取率：当前营业日规则 → 取当日 FR007@2026-04-29=0.10%
|
||
/// 口径：算头不算尾，计息天数=1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_CUR_001()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m, InterestRule_Cur);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [10_CUR_002] 算头不算尾 + 当前营业日规则 - 第3日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：算头不算尾（"10"）；interest_rule=0（当前营业日）
|
||
/// 操作：2026-04-28 未收盘；2026-04-30 盘中全平
|
||
/// 前置：提供 FR007@2026-04-30 数据
|
||
/// 取率：ResetPeriod=3天，从4/28到4/30=2天<3天（重置周期内）
|
||
/// 应取起息日利率 FR007@2026-04-28=0.10%
|
||
/// 口径：算头不算尾，计息天数=2天
|
||
/// 期望：计息天数=2天，利息=2*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_10_CUR_002()
|
||
{
|
||
var interest = CalcUnwind("10", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m, InterestRule_Cur);
|
||
var expected = ExpectedInterest(2, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
#region 场景3：不算头算尾 (InterestCalcMode="01")
|
||
#region 计息区间说明：
|
||
/// 01_001: 首日(4/28)平仓 → S=4/29, E=4/28 → 0天
|
||
/// 01_002: 次日(4/29)全平 → S=4/29, E=4/29 → 1天
|
||
/// 01_003: 次日(4/29)半平 → 1天×50%
|
||
/// 01_004: 第3日(4/30)全平 → S=4/29, E=4/30 → 1天
|
||
/// 01_005: 跨周期(5/6)全平 → 0天
|
||
/// 01_EOD_001: 首日(4/28)收盘 → 0天
|
||
/// 01_EOD_002: 4/28收盘 → 4/29全平 → 1天
|
||
#endregion
|
||
/// ================================================================ */
|
||
|
||
/// <summary>
|
||
/// [01_001] 不算头算尾 - 首日起息日平仓
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日StartDate）盘中执行全平
|
||
/// 口径：不算头算尾
|
||
/// - 不算头：S=4/29（起息日次日）
|
||
/// - 算尾：E=4/28（操作日）
|
||
/// - 计息天数 = 4/28 - 4/29 = -1 → 0天
|
||
/// 期望：计息天数=0天，利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_PRE_001()
|
||
{
|
||
var interest = CalcUnwind("01", new DateTime(2026, 4, 28), new DateTime(2026, 4, 28), 1m);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [01_002] 不算头算尾 - 次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行全平
|
||
/// 口径：不算头算尾
|
||
/// - 不算头：S=4/29（下一日起息）
|
||
/// - 算尾：E=4/29（操作日）
|
||
/// - 计息天数 = 4/29 - 4/29 = 1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_PRE_002()
|
||
{
|
||
var interest = CalcUnwind("01", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [01_003] 不算头算尾 - 次日平仓50%
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行平仓一半
|
||
/// 口径：不算头算尾，计息天数=1天
|
||
/// 期望：计息天数=1天，利息=0.5*1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_PRE_003()
|
||
{
|
||
var interest = CalcUnwind("01", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 0.5m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal * 0.5m);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [01_004] 不算头算尾 - 第3日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-30 盘中全平
|
||
/// 口径：不算头算尾
|
||
/// - 不算头：S=4/29（下一日起息）
|
||
/// - 算尾：E=4/30（操作日）
|
||
/// - 计息天数 = 4/30 - 4/29 = 1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_PRE_004()
|
||
{
|
||
var interest = CalcUnwind("01", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [01_EOD_001] 不算头算尾 - 首日收盘归档
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日）执行收盘EOD归档
|
||
/// 口径：不算头算尾
|
||
/// - 不算头：S=4/29
|
||
/// - 算尾：E=4/28 → 计息天数=0
|
||
/// 期望：当日收盘利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_EOD_001()
|
||
{
|
||
var interest = CalcEod("01", new DateTime(2026, 4, 28), new List<eod_swap_position>());
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [01_EOD_002] 不算头算尾 - 前日已收盘，次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘归档；2026-04-29 盘中执行全平
|
||
/// 口径：不算头算尾
|
||
/// - 不算头：S=4/29
|
||
/// - 算尾：E=4/29
|
||
/// - 计息天数=1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_EOD_002()
|
||
{
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m, 0m)
|
||
};
|
||
var interest = CalcUnwind("01", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m, eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [01_005] 不算头算尾 - 跨周期全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 未平仓；2026-05-06 跨周期全平
|
||
/// 口径：不算头算尾
|
||
/// - 不算头：S=5/7（下一周期起息日）
|
||
/// - 算尾：E=5/6
|
||
/// - 计息天数 = 5/6 - 5/7 = -1 → 0天
|
||
/// 期望：计息天数=0天，利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_01_PRE_005()
|
||
{
|
||
var interest = CalcUnwind("01", new DateTime(2026, 5, 6), new DateTime(2026, 5, 6), 1m);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 场景4：不算头不算尾 (InterestCalcMode="00")
|
||
#region 计息区间说明：
|
||
/// 00_001: 首日(4/28)平仓 → S=4/29, E=4/27 → 0天
|
||
/// 00_002: 次日(4/29)全平 → S=4/29, E=4/28 → 0天
|
||
/// 00_003: 第3日(4/30)全平 → S=4/29, E=4/29 → 0天
|
||
/// 00_004: 跨周期(5/6)全平 → 0天
|
||
/// 00_EOD_001: 首日(4/28)收盘 → 0天
|
||
/// 00_EOD_002: 4/28收盘 → 4/29全平 → 0天
|
||
#endregion
|
||
/// ================================================================ */
|
||
|
||
/// <summary>
|
||
/// [00_001] 不算头不算尾 - 首日起息日平仓
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日StartDate）盘中执行全平
|
||
/// 口径：不算头不算尾
|
||
/// - 不算头：S=4/29
|
||
/// - 不算尾：E=4/27
|
||
/// - 计息天数 = 4/27 - 4/29 = -2 → 0天
|
||
/// 期望：计息天数=0天，利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_00_PRE_001()
|
||
{
|
||
var interest = CalcUnwind("00", new DateTime(2026, 4, 28), new DateTime(2026, 4, 28), 1m);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [00_002] 不算头不算尾 - 次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行全平
|
||
/// 口径：不算头不算尾
|
||
/// - 不算头：利息从4/29开始（跨到下一周期）
|
||
/// - 不算尾：E=4/28
|
||
/// - 计息区间：4/29-5/1 → 1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_00_PRE_002()
|
||
{
|
||
var interest = CalcUnwind("00", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [00_003] 不算头不算尾 - 第3日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-30 盘中全平
|
||
/// 口径：不算头不算尾
|
||
/// - 不算头：利息从4/30开始（跨到下一周期）
|
||
/// - 不算尾：E=4/29（减1天）
|
||
/// - 计息区间：4/30-5/1 → 1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_00_PRE_003()
|
||
{
|
||
var interest = CalcUnwind("00", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [00_004] 不算头不算尾 - 跨周期全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 未平仓；2026-05-06 跨周期全平
|
||
/// 口径：不算头不算尾
|
||
/// - 不算头：S=5/7
|
||
/// - 不算尾：E=5/5
|
||
/// - 计息天数 = 5/5 - 5/7 = -2 → 0天
|
||
/// 期望：计息天数=0天，利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_00_PRE_004()
|
||
{
|
||
var interest = CalcUnwind("00", new DateTime(2026, 5, 6), new DateTime(2026, 5, 6), 1m);
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [00_EOD_001] 不算头不算尾 - 首日收盘归档
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28（起息日）执行收盘EOD归档
|
||
/// 口径：不算头不算尾
|
||
/// - 不算头：S=4/29
|
||
/// - 不算尾：E=4/27 → 计息天数=0
|
||
/// 期望：当日收盘利息=0
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_00_EOD_001()
|
||
{
|
||
var interest = CalcEod("00", new DateTime(2026, 4, 28), new List<eod_swap_position>());
|
||
Assert.AreEqual(0m, interest.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [00_EOD_002] 不算头不算尾 - 前日已收盘，次日全平
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 已收盘归档；2026-04-29 盘中执行全平
|
||
/// 口径：不算头不算尾
|
||
/// - 不算头：利息从4/29开始（跨到下一周期）
|
||
/// - 不算尾：E=4/28（减1天）
|
||
/// - 计息区间：4/29-5/1 → 1天
|
||
/// 期望：计息天数=1天，利息=1*(1.00%+0.10%)*1000/365
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_00_EOD_002()
|
||
{
|
||
var eodPositions = new List<eod_swap_position>
|
||
{
|
||
CreateEodPosition(new DateTime(2026, 4, 28), Principal, 0.001m, 0m)
|
||
};
|
||
var interest = CalcUnwind("00", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m, eodPositions);
|
||
var expected = ExpectedInterest(1, FixedRate, 0.001m, Principal);
|
||
Assert.AreEqual(expected, interest.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 场景5：口径对比验证
|
||
#region 对比测试说明：
|
||
/// COMPARE_001: 同一日(4/29)全平，4种口径对比
|
||
/// COMPARE_002: 同一日(4/30)全平，4种口径对比
|
||
#endregion
|
||
/// ================================================================ */
|
||
|
||
/// <summary>
|
||
/// [COMPARE_001] 口径对比 - 同一日(4/29)全平，4种口径对比验证
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-29 盘中执行全平
|
||
/// 操作：对同一操作日(4/29)分别用4种计息口径执行"全平"
|
||
/// 对比结果：
|
||
/// - "11"算头算尾: S=4/28, E=4/29 → 2天
|
||
/// - "10"算头不算尾: S=4/28, E=4/28 → 1天
|
||
/// - "01"不算头算尾: S=4/29, E=4/29 → 1天
|
||
/// - "00"不算头不算尾: S=4/29, E=5/1 → 1天（中间日期跨周期）
|
||
/// 期望：验证4种口径的差异符合预期
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_COMPARE_001()
|
||
{
|
||
// "11"算头算尾: S=4/28, E=4/29 => 2天
|
||
var interest11 = CalcUnwind("11", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
Assert.AreEqual(ExpectedInterest(2, FixedRate, 0.001m, Principal), interest11.InterestAmount);
|
||
|
||
// "10"算头不算尾: S=4/28, E=4/28 => 1天
|
||
var interest10 = CalcUnwind("10", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
Assert.AreEqual(ExpectedInterest(1, FixedRate, 0.001m, Principal), interest10.InterestAmount);
|
||
|
||
// "01"不算头算尾: S=4/29, E=4/29 => 1天
|
||
var interest01 = CalcUnwind("01", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
Assert.AreEqual(ExpectedInterest(1, FixedRate, 0.001m, Principal), interest01.InterestAmount);
|
||
|
||
// "00"不算头不算尾: S=4/29, E=5/1 => 1天（中间日期跨周期）
|
||
var interest00 = CalcUnwind("00", new DateTime(2026, 4, 29), new DateTime(2026, 4, 29), 1m);
|
||
Assert.AreEqual(ExpectedInterest(1, FixedRate, 0.001m, Principal), interest00.InterestAmount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// [COMPARE_002] 口径对比 - 同一日(4/30)全平，4种口径对比验证
|
||
/// ---------------------------------------------------------------
|
||
/// 场景：2026-04-28 盘中未平仓；2026-04-30 盘中执行全平（跨周末）
|
||
/// 操作：对同一操作日(4/30)分别用4种计息口径执行"全平"
|
||
/// 对比结果：
|
||
/// - "11"算头算尾: S=4/28, E=4/30 → 3天
|
||
/// - "10"算头不算尾: S=4/28, E=4/29 → 2天
|
||
/// - "01"不算头算尾: S=4/29, E=4/30 → 1天
|
||
/// - "00"不算头不算尾: S=4/30, E=5/1 → 1天（中间日期跨周期）
|
||
/// 期望：验证4种口径的差异符合预期
|
||
/// ---------------------------------------------------------------
|
||
/// </summary>
|
||
[TestMethod]
|
||
public void UT_SWAP_INT_COMPARE_002()
|
||
{
|
||
// "11"算头算尾: S=4/28, E=4/30 => 3天
|
||
var interest11 = CalcUnwind("11", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
Assert.AreEqual(ExpectedInterest(3, FixedRate, 0.001m, Principal), interest11.InterestAmount);
|
||
|
||
// "10"算头不算尾: S=4/28, E=4/29 => 2天
|
||
var interest10 = CalcUnwind("10", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
Assert.AreEqual(ExpectedInterest(2, FixedRate, 0.001m, Principal), interest10.InterestAmount);
|
||
|
||
// "01"不算头算尾: S=4/29, E=4/30 => 1天
|
||
var interest01 = CalcUnwind("01", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
Assert.AreEqual(ExpectedInterest(1, FixedRate, 0.001m, Principal), interest01.InterestAmount);
|
||
|
||
// "00"不算头不算尾: S=4/30, E=5/1 => 1天（中间日期跨周期）
|
||
var interest00 = CalcUnwind("00", new DateTime(2026, 4, 30), new DateTime(2026, 4, 30), 1m);
|
||
Assert.AreEqual(ExpectedInterest(1, FixedRate, 0.001m, Principal), interest00.InterestAmount);
|
||
}
|
||
|
||
#endregion
|
||
|
||
}
|
||
}
|