风险提示：本文为MQL5编程技术分享文章，所有代码示例与架构设计均用于学习研究和技术交流目的，不构成任何投资建议或交易策略推荐。金融市场交易存在亏损风险，任何EA或策略的历史表现均不代表未来收益。读者应在充分理解代码逻辑和交易风险的前提下自行决策，谨慎使用。

重点：单元测试对EA开发的核心价值体现在三个方面：①它是重构的安全网——有了测试兜底，你敢大胆改代码；②它是迭代的加速剂——每次修改后一键跑测试，效率比手动回测高一个数量级；③它是质量的度量衡——测试覆盖率让质量从"感觉还行"变成"数据说话"。据行业调研，引入完整单元测试体系的量化团队，EA线上Bug率可下降约40%，重大功能迭代周期缩短约30%。

概念：单元测试（Unit Testing）是一种软件测试方法，用于验证代码中最小的可测试单元（函数、方法或类）是否按照预期工作。每个单元测试用例独立运行，通过断言（Assertion）判断实际输出是否等于预期输出。单元测试的核心原则是：隔离性（每个测试互不干扰）、可重复性（每次运行结果一致）、自动化（一键运行全部用例）。

概念：测试金字塔（Test Pyramid）是软件测试领域的经典模型，由Mike Cohn提出。它将测试分为多个层级，越靠底层测试粒度越小、运行速度越快、数量越多；越靠顶层测试粒度越大、运行速度越慢、数量越少。金字塔形状代表了各层测试用例的理想数量比例——底层多、顶层少，这样的测试体系运行效率最高、维护成本最低。

重点：测试金字塔的核心智慧是"把问题尽量在底层解决"。一个边界条件的问题，如果在单元测试层发现，可能只需要5分钟修复；如果到了回测层才发现，可能需要半小时排查；如果到了实盘层才暴露，可能造成实际资金损失。很多开发者跳过单元测试直接跑回测，相当于用大炮打蚊子——既低效又昂贵。

进阶：测试金字塔不是固定不变的教条，而是一种指导思想。在EA开发中，你可能还需要增加一些特殊层级，比如"数据质量测试"（验证行情数据的完整性和准确性）、"参数边界测试"（验证极端参数下策略的鲁棒性）。核心原则是：越容易自动化、越快速的测试，越应该放在下层，数量越多；越依赖真实环境、越慢的测试，越应该放在上层，数量越少。

操作建议：选型决策三原则——①新手起步原则：如果你之前完全没接触过单元测试，建议先从自制测试宏开始，理解断言、测试用例、测试套件这些核心概念，再考虑引入框架。②规模匹配原则：单个EA文件、几百行代码的小项目，用MQLUNIT足够；多个文件、多模块协作的中大型项目，建议上MQL5Unit。③团队协作原则：如果是团队开发，统一使用MQL5Unit这样的主流框架，有完善的文档和社区支持，新人上手更快，测试报告也便于团队共享。

风险：不要陷入"框架选型强迫症"。框架只是工具，不是目的。很多开发者花了大量时间对比各种框架的优劣，迟迟不肯动手写第1个测试，这是典型的"工具准备过度"。记住：用任何一个框架写出10个测试用例，都比研究10个框架却一个测试没写强得多。选一个能快速上手的方案，先跑起来，后续再根据需要迁移到更完善的框架。

风险：所有代码示例均基于MQL5严格模式（#property strict）编写。MQL4与MQL5在类、继承、模板等方面有差异，如果你的项目是MQL4，需要做相应调整。复制代码后请先在MetaEditor中编译验证，确认无错误后再投入使用。

//+------------------------------------------------------------------+
//|                                                    TestCase.mqh  |
//|                        MQL5单元测试基类 —— 可直接使用              |
//+------------------------------------------------------------------+
#property copyright "xiaohui"
#property version   "1.00"
#property strict

// 测试结果结构
struct TestResult
{
   string  testName;       // 测试方法名
   bool    passed;         // 是否通过
   string  message;        // 失败信息
   int     line;           // 失败行号
   double  elapsedMs;      // 运行耗时(毫秒)
};

//+------------------------------------------------------------------+
//|                          TestCase 基类                            |
//+------------------------------------------------------------------+
class TestCase
{
protected:
   int            m_total;        // 总测试数
   int            m_passed;       // 通过数
   int            m_failed;       // 失败数
   TestResult     m_results[];    // 测试结果数组
   string         m_className;    // 测试类名
   datetime       m_startTime;    // 开始时间
   ulong          m_testStartMs;  // 单个测试开始时间

public:
   TestCase(const string className) : m_total(0), m_passed(0), m_failed(0)
   {
      m_className = className;
      m_startTime = TimeCurrent();
      Print("===== 开始测试: ", m_className, " =====");
   }

   ~TestCase()
   {
      PrintReport();
   }

   // 测试运行入口 —— 子类重写此方法
   virtual void Run() = 0;

   //+--------------------------------------------------------------+
   //|                       断言函数组                              |
   //+--------------------------------------------------------------+

   // 整数断言相等
   void AssertEqual(int expected, int actual, const string msg="", int line=0)
   {
      if(expected == actual)
         PassTest();
      else
         FailTest(StringFormat("期望 %d, 实际 %d. %s", expected, actual, msg), line);
   }

   // 布尔断言
   void AssertTrue(bool condition, const string msg="", int line=0)
   {
      if(condition)
         PassTest();
      else
         FailTest("断言失败: 期望 true, 实际 false. " + msg, line);
   }

   void AssertFalse(bool condition, const string msg="", int line=0)
   {
      if(!condition)
         PassTest();
      else
         FailTest("断言失败: 期望 false, 实际 true. " + msg, line);
   }

   // 字符串断言
   void AssertString(const string &expected, const string &actual,
                     const string msg="", int line=0)
   {
      if(expected == actual)
         PassTest();
      else
         FailTest(StringFormat("期望 '%s', 实际 '%s'. %s",
                               expected, actual, msg), line);
   }

   // 双精度断言（带精度容差）
   void AssertDouble(double expected, double actual,
                     double epsilon=0.00001, const string msg="", int line=0)
   {
      if(MathAbs(expected - actual) <= epsilon)
         PassTest();
      else
         FailTest(StringFormat("期望 %.6f, 实际 %.6f, 差值 %.6f. %s",
                               expected, actual, MathAbs(expected-actual), msg), line);
   }

   // 非空断言
   template
   void AssertNotNull(T *ptr, const string msg="", int line=0)
   {
      if(CheckPointer(ptr) != POINTER_INVALID)
         PassTest();
      else
         FailTest("断言失败: 指针为NULL. " + msg, line);
   }

   //+--------------------------------------------------------------+
   //|                     测试执行辅助方法                          |
   //+--------------------------------------------------------------+

   // 开始单个测试
   void BeginTest(const string testName)
   {
      m_testStartMs = GetTickCount64();
      SetUp();
      Print("  [运行] ", testName);
   }

   // 结束单个测试 —— 记录结果
   void EndTest(const string testName)
   {
      TearDown();
      double elapsed = (GetTickCount64() - m_testStartMs) / 1.0;

      int idx = m_total - 1;  // 最后一个记录的索引
      if(idx >= 0 && idx < ArraySize(m_results))
      {
         m_results[idx].testName = testName;
         m_results[idx].elapsedMs = elapsed;
      }
   }

   //+--------------------------------------------------------------+
   //|                   SetUp / TearDown 钩子                      |
   //+--------------------------------------------------------------+
   virtual void SetUp()    { /* 子类重写：每个测试前执行 */ }
   virtual void TearDown() { /* 子类重写：每个测试后执行 */ }

   //+--------------------------------------------------------------+
   //|                         报告输出                             |
   //+--------------------------------------------------------------+
   void PrintReport()
   {
      Print("");
      Print("===== 测试报告: ", m_className, " =====");
      Print("  总计: ", m_total, " 个测试");
      Print("  通过: ", m_passed, " 个");
      Print("  失败: ", m_failed, " 个");

      if(m_failed > 0)
      {
         Print("");
         Print("  --- 失败详情 ---");
         for(int i = 0; i < m_total; i++)
         {
            if(!m_results[i].passed)
            {
               Print("  ✗ ", m_results[i].testName, " : ", m_results[i].message);
               if(m_results[i].line > 0)
                  Print("     行号: ", m_results[i].line);
            }
         }
      }

      double passRate = (m_total > 0) ? (m_passed * 100.0 / m_total) : 0;
      Print("");
      Print(StringFormat("  通过率: %.1f%%", passRate));
      Print("=====================================");
   }

protected:
   // 内部方法：通过一个测试
   void PassTest()
   {
      m_total++;
      m_passed++;
      AddResult(true, "", 0);
   }

   // 内部方法：失败一个测试
   void FailTest(const string msg, int line)
   {
      m_total++;
      m_failed++;
      AddResult(false, msg, line);
   }

   void AddResult(bool passed, const string msg, int line)
   {
      int idx = ArraySize(m_results);
      ArrayResize(m_results, idx + 1);
      m_results[idx].passed = passed;
      m_results[idx].message = msg;
      m_results[idx].line = line;
   }
};
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                  DemoTest.mq5     |
//|                         使用示例：计算器测试                      |
//+------------------------------------------------------------------+
#property strict
#include "TestCase.mqh"

class CalculatorTest : public TestCase
{
public:
   CalculatorTest() : TestCase("CalculatorTest") {}

   virtual void Run() override
   {
      TestAddition();
      TestSubtraction();
      TestDivisionByZero();
   }

   void TestAddition()
   {
      BeginTest("TestAddition");
      AssertEqual(5, 2 + 3, "加法计算错误", __LINE__);
      AssertEqual(0, -5 + 5, "正负相加错误", __LINE__);
      EndTest("TestAddition");
   }

   void TestSubtraction()
   {
      BeginTest("TestSubtraction");
      AssertEqual(2, 5 - 3, "减法计算错误", __LINE__);
      EndTest("TestSubtraction");
   }

   void TestDivisionByZero()
   {
      BeginTest("TestDivisionByZero");
      // 验证除零保护：我们的安全除法函数应返回0而非崩溃
      double result = SafeDivide(10.0, 0.0);
      AssertDouble(0.0, result, 0.0001, "除零应返回0", __LINE__);
      EndTest("TestDivisionByZero");
   }

   double SafeDivide(double a, double b)
   {
      if(b == 0.0) return 0.0;
      return a / b;
   }
};

// 在OnInit中运行所有测试
int OnInit()
{
   CalculatorTest test;
   test.Run();
   return(INIT_SUCCEEDED);
}

重点：这个测试基类虽然代码量不大，但已经具备了专业测试框架的核心要素：①多类型断言（int/double/string/bool/指针全覆盖）；②SetUp/TearDown生命周期钩子；③测试结果统计与通过率计算；④失败时记录行号和错误信息；⑤运行耗时统计。对于中小型EA项目，这个基类完全够用。如果后续需要更复杂的功能（如参数化测试、测试套件聚合），再考虑迁移到MQL5Unit也不迟。

操作建议：把上面的TestCase.mqh保存到你的MQL5 Include目录下（通常是 MQL5/Include/ 文件夹），这样任何项目都可以通过 #include 来引用。建议建一个专门的测试目录（如 MQL5/Experts/Tests/），所有测试脚本放在一起，和正式业务代码隔离开，保持项目结构清晰。

概念：Mock（模拟对象）是单元测试中的核心技术，指用一个"假的"对象来代替真实的外部依赖，让被测代码以为自己在和真实系统交互。Mock可以精确控制返回值、验证调用行为，从而将被测逻辑与外部依赖完全隔离。EA开发中常见的Mock对象包括：行情数据Mock、账户信息Mock、交易执行Mock、时间系统Mock等。

// 不好测的写法：函数内部直接依赖外部系统
double CalculateStopLoss(string symbol, int atrPeriod, double atrMultiplier)
{
   double atr = iATR(symbol, PERIOD_CURRENT, atrPeriod, 0);  // 依赖行情
   double price = SymbolInfoDouble(symbol, SYMBOL_BID);       // 依赖行情
   double stopLoss = price - atr * atrMultiplier;
   return stopLoss;
}

// 好测的写法：把依赖数据作为参数注入
double CalculateStopLoss(double currentPrice, double atrValue, double atrMultiplier)
{
   // 纯计算逻辑，不依赖任何外部系统
   double stopLoss = currentPrice - atrValue * atrMultiplier;
   return stopLoss;
}

// 调用方负责获取数据并传入
// （在真实EA中调用）
double atr = iATR(_Symbol, PERIOD_CURRENT, atrPeriod, 0);
double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double sl = CalculateStopLoss(price, atr, atrMultiplier);

// （在单元测试中调用）
double sl = CalculateStopLoss(1.1000, 0.0050, 2.0);
// 期望: 1.1000 - 0.0050 * 2.0 = 1.0900
AssertDouble(1.0900, sl, 0.0001, "止损计算错误", __LINE__);

操作建议：参数注入是新手入门Mock的首选方案，零学习成本、零框架依赖。你需要做的就是养成一个编程习惯：写函数时问自己"这个函数的职责是计算还是获取数据？"如果是计算，就不要在里面调用iCustom、AccountBalance这类外部函数，把数据从参数传进来。这种简单的习惯改变，能让你的代码可测试性提升一个档次。

// RiskManager.mqh —— 使用条件编译隔离外部依赖

// 测试模式下，使用Mock数据
#ifdef TEST_MODE
   // 模拟行情数据的全局变量（测试时手动设置）
   double   g_mockATR = 0.0;
   double   g_mockBalance = 10000.0;
   double   g_mockEquity = 10000.0;

   double   Mock_GetATR()      { return g_mockATR; }
   double   Mock_GetBalance()  { return g_mockBalance; }
   double   Mock_GetEquity()   { return g_mockEquity; }
#else
   // 真实模式下，调用MT5原生函数
   double   Mock_GetATR()      { return iATR(_Symbol, PERIOD_CURRENT, 14, 0); }
   double   Mock_GetBalance()  { return AccountInfoDouble(ACCOUNT_BALANCE); }
   double   Mock_GetEquity()   { return AccountInfoDouble(ACCOUNT_EQUITY); }
#endif

class RiskManager
{
public:
   double CalculatePositionSize(double riskPercent)
   {
      double balance = Mock_GetBalance();   // 通过统一接口获取
      double atr = Mock_GetATR();
      if(atr <= 0 || balance <= 0) return 0.0;
      double riskAmount = balance * riskPercent / 100.0;
      double lotSize = riskAmount / (atr * 100000);  // 简化示例
      return lotSize;
   }
};

// RiskManagerTest.mq5 —— 测试脚本
#property strict
#define TEST_MODE          // 启用测试模式
#include "RiskManager.mqh"
#include "TestCase.mqh"

class RiskManagerTest : public TestCase
{
public:
   RiskManagerTest() : TestCase("RiskManagerTest") {}

   virtual void Run() override
   {
      TestNormalPositionSize();
      TestZeroATR();
      TestHighRiskPercent();
   }

   void TestNormalPositionSize()
   {
      BeginTest("TestNormalPositionSize");
      // 设置Mock数据
      g_mockBalance = 10000.0;
      g_mockATR = 0.0050;

      RiskManager rm;
      double lot = rm.CalculatePositionSize(1.0);
      // 期望: 10000 * 0.01 / (0.0050 * 100000) = 100 / 500 = 0.2
      AssertDouble(0.2, lot, 0.001, "正常仓位计算错误", __LINE__);
      EndTest("TestNormalPositionSize");
   }

   void TestZeroATR()
   {
      BeginTest("TestZeroATR");
      g_mockATR = 0.0;
      g_mockBalance = 10000.0;

      RiskManager rm;
      double lot = rm.CalculatePositionSize(1.0);
      AssertDouble(0.0, lot, 0.0001, "ATR为0应返回0手", __LINE__);
      EndTest("TestZeroATR");
   }
   // ... 更多测试用例
};

重点：条件编译方案的优势在于：①侵入性低——不需要改架构，只需要在调用外部函数的地方包一层；②零运行时开销——发布版本中条件编译块会被完全优化掉，不影响性能；③适合存量项目快速接入测试。但它也有缺点：Mock粒度比较粗，每个测试用例之间要手动管理Mock状态，容易忘。这种方案更适合作为"过渡方案"，等项目逐步重构后再迁移到更优雅的接口抽象方案。

进阶：接口抽象类方案本质上是依赖倒置原则（DIP）的应用——高层模块不应该依赖低层模块，两者都应该依赖抽象。在EA开发中，这意味着：你的策略逻辑（高层）不应该直接依赖MT5 API（低层），而是依赖一个你自己定义的"行情/账户/交易"抽象接口。这样做的好处不仅是可测试性好，还能让你的策略逻辑与具体平台解耦，未来如果要迁移到其他交易平台，只需要重新实现接口层，策略代码一行都不用改。

// IMarketData.mqh —— 行情数据接口
class IMarketData
{
public:
   virtual double   GetATR(string symbol, ENUM_TIMEFRAMES tf, int period, int shift) = 0;
   virtual double   GetClose(string symbol, ENUM_TIMEFRAMES tf, int shift) = 0;
   virtual double   GetBid(string symbol) = 0;
   virtual int      GetBars(string symbol, ENUM_TIMEFRAMES tf) = 0;
   virtual          ~IMarketData() {}
};

// IAccountInfo.mqh —— 账户信息接口
class IAccountInfo
{
public:
   virtual double   GetBalance() = 0;
   virtual double   GetEquity() = 0;
   virtual double   GetMarginFree() = 0;
   virtual string   GetCurrency() = 0;
   virtual          ~IAccountInfo() {}
};

// ITradeExecutor.mqh —— 交易执行接口
class ITradeExecutor
{
public:
   virtual bool   OpenBuy(string symbol, double lot, double price,
                          double sl, double tp, string comment="") = 0;
   virtual bool   OpenSell(string symbol, double lot, double price,
                           double sl, double tp, string comment="") = 0;
   virtual bool   ClosePosition(ulong ticket) = 0;
   virtual        ~ITradeExecutor() {}
};

// MockMarketData.mqh —— Mock行情数据实现
class MockMarketData : public IMarketData
{
public:
   // 可手动设置的Mock数据
   double   mockATR;
   double   mockClose[100];  // 最近100根K线收盘价
   double   mockBid;
   int      mockBars;

   MockMarketData() : mockATR(0.0050), mockBid(1.1000), mockBars(1000)
   {
      ArrayInitialize(mockClose, 1.1000);
   }

   virtual double GetATR(string symbol, ENUM_TIMEFRAMES tf,
                         int period, int shift) override
   {
      return mockATR;  // 直接返回预设值
   }

   virtual double GetClose(string symbol, ENUM_TIMEFRAMES tf, int shift) override
   {
      if(shift >= 0 && shift < 100) return mockClose[shift];
      return 1.1000;
   }

   virtual double GetBid(string symbol) override { return mockBid; }
   virtual int    GetBars(string symbol, ENUM_TIMEFRAMES tf) override { return mockBars; }
};

// ATRStopLoss.mqh —— 业务逻辑类，只依赖接口
class ATRStopLoss
{
private:
   IMarketData   *m_market;     // 依赖抽象接口，而非具体实现
   double         m_multiplier;

public:
   // 构造函数注入依赖
   ATRStopLoss(IMarketData *market, double multiplier)
      : m_market(market), m_multiplier(multiplier) {}

   double CalculateSL(string symbol, ENUM_TIMEFRAMES tf, int atrPeriod)
   {
      double atr = m_market.GetATR(symbol, tf, atrPeriod, 0);
      double price = m_market.GetBid(symbol);
      if(atr <= 0) return 0.0;
      return price - atr * m_multiplier;
   }
};

// ATRStopLossTest.mq5 —— 单元测试
void TestSLCalculation()
{
   BeginTest("TestSLCalculation");

   MockMarketData mock;
   mock.mockATR = 0.0050;
   mock.mockBid = 1.1000;

   ATRStopLoss slCalc(&mock, 2.0);  // 注入Mock对象
   double sl = slCalc.CalculateSL("EURUSD", PERIOD_H1, 14);

   // 期望: 1.1000 - 0.0050 * 2.0 = 1.0900
   AssertDouble(1.0900, sl, 0.00001, "止损价计算错误", __LINE__);
   EndTest("TestSLCalculation");
}

风险：不要一上来就追求"最完美的架构"。很多开发者学了接口抽象类方案后，觉得这才是"正确的做法"，非要给所有东西都做抽象接口，结果项目还没写几行业务代码，先写了十几个接口类，过度设计反而拖慢了开发速度。记住：架构是服务于业务的，不是反过来。小项目用参数注入就够了，中等项目可以考虑条件编译，大型项目或长期维护的项目才需要接口抽象类。选择适合你当前阶段的方案，比选择"理论上最优"的方案更重要。

// ATRRiskManager.mqh
#property strict

class ATRRiskManager
{
private:
   double   m_accountBalance;   // 账户余额
   double   m_riskPercent;      // 单笔风险比例(%)
   double   m_atrMultiplier;    // ATR倍数
   double   m_minLot;           // 最小手数
   double   m_maxLot;           // 最大手数
   double   m_lotStep;          // 手数步长

public:
   ATRRiskManager(double balance, double riskPct, double atrMult,
                  double minLot=0.01, double maxLot=100.0, double lotStep=0.01)
      : m_accountBalance(balance), m_riskPercent(riskPct),
        m_atrMultiplier(atrMult), m_minLot(minLot),
        m_maxLot(maxLot), m_lotStep(lotStep) {}

   // 计算开仓手数
   double CalculateLotSize(double atrValue, double pointValuePerLot)
   {
      // 有效性检查
      if(atrValue <= 0.0 || pointValuePerLot <= 0.0) return 0.0;
      if(m_accountBalance <= 0.0 || m_riskPercent <= 0.0) return 0.0;
      if(m_riskPercent > 100.0) return 0.0;  // 风险比例不能超过百分之百

      // 风险金额 = 余额 × 风险比例
      double riskAmount = m_accountBalance * m_riskPercent / 100.0;

      // 止损距离对应的每手风险 = ATR × 倍数 × 每点价值
      double riskPerLot = atrValue * m_atrMultiplier * pointValuePerLot;
      if(riskPerLot <= 0.0) return 0.0;

      // 计算手数 = 风险金额 / 每手风险
      double lot = riskAmount / riskPerLot;

      // 规范化手数（对齐步长、限制范围）
      lot = NormalizeDouble(MathFloor(lot / m_lotStep) * m_lotStep, 2);
      if(lot < m_minLot) lot = 0.0;  // 不够最小手数就不开仓
      if(lot > m_maxLot) lot = m_maxLot;

      return lot;
   }

   // 计算止损价（做多时）
   double CalculateLongStopLoss(double entryPrice, double atrValue)
   {
      if(atrValue <= 0.0 || entryPrice <= 0.0) return 0.0;
      return entryPrice - atrValue * m_atrMultiplier;
   }

   // 计算止盈价（做多时，基于盈亏比）
   double CalculateLongTakeProfit(double entryPrice, double atrValue,
                                  double rewardRiskRatio)
   {
      if(atrValue <= 0.0 || entryPrice <= 0.0 || rewardRiskRatio <= 0.0)
         return 0.0;
      return entryPrice + atrValue * m_atrMultiplier * rewardRiskRatio;
   }

   // 更新余额（账户变化时调用）
   void   UpdateBalance(double newBalance) { m_accountBalance = newBalance; }
   double GetBalance() const               { return m_accountBalance; }
};

概念：测试用例设计（Test Case Design）是单元测试中的重要环节，指的是系统地设计输入数据和预期输出，确保被测逻辑的各个分支和边界都被验证到。常见的设计方法包括：等价类划分（将相似输入归为一类，每类选一个代表）、边界值分析（重点测试边界条件，如0、最大值、最小值）、错误推测法（根据经验猜测可能出错的地方）。

// ATRRiskManagerTest.mq5 —— ATR风控模块完整单元测试
#property strict
#include "TestCase.mqh"
#include "ATRRiskManager.mqh"

class ATRRiskManagerTest : public TestCase
{
public:
   ATRRiskManagerTest() : TestCase("ATRRiskManagerTest") {}

   virtual void Run() override
   {
      // 正常输入测试
      TestNormalLotCalculation();
      TestSmallRiskPercent();

      // 边界条件测试
      TestZeroATR();
      TestZeroRiskPercent();
      TestMinLotBoundary();
      TestMaxLotCap();

      // 异常输入测试
      TestNegativeATR();
      TestRiskPercentOver100();
      TestNegativeBalance();

      // 止损止盈测试
      TestLongStopLossCalculation();
      TestLongTakeProfitCalculation();

      // 状态更新测试
      TestBalanceUpdate();
   }

   // === 正常输入测试 ===

   void TestNormalLotCalculation()
   {
      BeginTest("TestNormalLotCalculation");
      // 余额10000, 风险1%, ATR倍数2
      ATRRiskManager rm(10000.0, 1.0, 2.0);
      // ATR=0.0050, 假设每点价值10美元（标准手EURUSD类似）
      double lot = rm.CalculateLotSize(0.0050, 10.0 / 0.0001);
      // 计算过程:
      // 风险金额 = 10000 * 1% = 100
      // 每手风险 = 0.0050 * 2 * 100000 = 1000 (每手ATR止损对应1000美元风险)
      // 手数 = 100 / 1000 = 0.1
      AssertDouble(0.1, lot, 0.001, "正常手数计算错误", __LINE__);
      EndTest("TestNormalLotCalculation");
   }

   void TestSmallRiskPercent()
   {
      BeginTest("TestSmallRiskPercent");
      ATRRiskManager rm(5000.0, 0.5, 1.5, 0.01, 100.0, 0.01);
      double lot = rm.CalculateLotSize(0.0100, 10.0 / 0.0001);
      // 风险金额 = 5000 * 0.5% = 25
      // 每手风险 = 0.0100 * 1.5 * 100000 = 1500
      // 手数 = 25 / 1500 = 0.0166 → 向下取整到0.01步长 = 0.01
      AssertDouble(0.01, lot, 0.001, "小风险比例手数计算错误", __LINE__);
      EndTest("TestSmallRiskPercent");
   }

   // === 边界条件测试 ===

   void TestZeroATR()
   {
      BeginTest("TestZeroATR");
      ATRRiskManager rm(10000.0, 1.0, 2.0);
      double lot = rm.CalculateLotSize(0.0, 100000.0);
      AssertDouble(0.0, lot, 0.0001, "ATR为0应返回0手", __LINE__);
      EndTest("TestZeroATR");
   }

   void TestZeroRiskPercent()
   {
      BeginTest("TestZeroRiskPercent");
      ATRRiskManager rm(10000.0, 0.0, 2.0);
      double lot = rm.CalculateLotSize(0.0050, 100000.0);
      AssertDouble(0.0, lot, 0.0001, "风险比例为0应返回0手", __LINE__);
      EndTest("TestZeroRiskPercent");
   }

   void TestMinLotBoundary()
   {
      BeginTest("TestMinLotBoundary");
      // 计算出的手数刚好略小于最小手数，应返回0
      ATRRiskManager rm(100.0, 1.0, 2.0, 0.10, 100.0, 0.01);
      double lot = rm.CalculateLotSize(0.0050, 100000.0);
      // 风险金额 = 100 * 1% = 1
      // 每手风险 = 0.0050 * 2 * 100000 = 1000
      // 手数 = 1 / 1000 = 0.001 → 小于0.1最小手数 → 返回0
      AssertDouble(0.0, lot, 0.0001, "低于最小手数应返回0", __LINE__);
      EndTest("TestMinLotBoundary");
   }

   void TestMaxLotCap()
   {
      BeginTest("TestMaxLotCap");
      // 计算出的手数超过最大限制，应被截断
      ATRRiskManager rm(1000000.0, 5.0, 1.0, 0.01, 5.0, 0.01);
      double lot = rm.CalculateLotSize(0.0020, 100000.0);
      // 风险金额 = 100万 * 5% = 50000
      // 每手风险 = 0.0020 * 1 * 100000 = 20
      // 手数 = 50000 / 20 = 2500 → 超过最大5手 → 返回5.0
      AssertDouble(5.0, lot, 0.001, "超过最大手数应被截断", __LINE__);
      EndTest("TestMaxLotCap");
   }

   // === 异常输入测试 ===

   void TestNegativeATR()
   {
      BeginTest("TestNegativeATR");
      ATRRiskManager rm(10000.0, 1.0, 2.0);
      double lot = rm.CalculateLotSize(-0.0050, 100000.0);
      AssertDouble(0.0, lot, 0.0001, "负ATR应返回0手", __LINE__);
      EndTest("TestNegativeATR");
   }

   void TestRiskPercentOver100()
   {
      BeginTest("TestRiskPercentOver100");
      ATRRiskManager rm(10000.0, 150.0, 2.0);
      double lot = rm.CalculateLotSize(0.0050, 100000.0);
      AssertDouble(0.0, lot, 0.0001, "风险比例超百分之百应返回0手", __LINE__);
      EndTest("TestRiskPercentOver100");
   }

   void TestNegativeBalance()
   {
      BeginTest("TestNegativeBalance");
      ATRRiskManager rm(-1000.0, 1.0, 2.0);
      double lot = rm.CalculateLotSize(0.0050, 100000.0);
      AssertDouble(0.0, lot, 0.0001, "负余额应返回0手", __LINE__);
      EndTest("TestNegativeBalance");
   }

   // === 止损止盈测试 ===

   void TestLongStopLossCalculation()
   {
      BeginTest("TestLongStopLossCalculation");
      ATRRiskManager rm(10000.0, 1.0, 2.0);
      double sl = rm.CalculateLongStopLoss(1.1000, 0.0050);
      // 1.1000 - 0.0050 * 2 = 1.0900
      AssertDouble(1.0900, sl, 0.00001, "做多止损价计算错误", __LINE__);
      EndTest("TestLongStopLossCalculation");
   }

   void TestLongTakeProfitCalculation()
   {
      BeginTest("TestLongTakeProfitCalculation");
      ATRRiskManager rm(10000.0, 1.0, 2.0);
      double tp = rm.CalculateLongTakeProfit(1.1000, 0.0050, 1.5);
      // 1.1000 + 0.0050 * 2 * 1.5 = 1.1000 + 0.015 = 1.1150
      AssertDouble(1.1150, tp, 0.00001, "做多止盈价计算错误", __LINE__);
      EndTest("TestLongTakeProfitCalculation");
   }

   // === 状态更新测试 ===

   void TestBalanceUpdate()
   {
      BeginTest("TestBalanceUpdate");
      ATRRiskManager rm(10000.0, 1.0, 2.0);

      // 初始余额计算
      double lot1 = rm.CalculateLotSize(0.0050, 100000.0);
      AssertDouble(0.1, lot1, 0.001, "初始余额手数错误", __LINE__);

      // 余额翻倍后，手数也应该翻倍
      rm.UpdateBalance(20000.0);
      double lot2 = rm.CalculateLotSize(0.0050, 100000.0);
      AssertDouble(0.2, lot2, 0.001, "余额更新后手数错误", __LINE__);

      // 余额减半后，手数也应该减半
      rm.UpdateBalance(5000.0);
      double lot3 = rm.CalculateLotSize(0.0050, 100000.0);
      AssertDouble(0.05, lot3, 0.001, "余额减少后手数错误", __LINE__);

      EndTest("TestBalanceUpdate");
   }
};

int OnInit()
{
   ATRRiskManagerTest test;
   test.Run();
   return(INIT_SUCCEEDED);
}

重点：仔细看这个测试文件，你会发现一个规律：每个测试用例都只验证一个东西，测试方法的命名清晰地描述了它在测什么。这是写好单元测试的两个关键习惯：①单一职责——一个测试只验证一个行为，失败了你立刻知道哪里出了问题；②自描述命名——测试方法名就是最好的文档，看名字就知道这个测试在做什么、预期结果是什么。好的测试命名通常遵循"测试场景 + 预期结果"的格式，比如TestZeroATR_ShouldReturnZeroLot。

操作建议：把上面的ATRRiskManager.mqh和ATRRiskManagerTest.mq5复制到你的MT5中，编译运行一下，亲眼看看测试结果输出。亲自运行一次的学习效果，比读十遍文章都好。运行之后，尝试故意把CalculateLotSize中的某个公式写错，看看测试会不会报失败、失败信息够不够清晰。这种"故意造Bug验证测试有效性"的练习，是提升测试设计能力的好方法。

概念：回归测试（Regression Testing）是指在代码修改后，重新运行已有测试，确保修改没有引入新的错误或导致已有功能退化。"回归"的意思是"退化、倒退"——我们要防止代码质量随着修改而倒退。自动化回归测试就是把这个过程自动化，一键运行全部测试，不需要人工干预。

; tester.ini —— MT5策略测试命令行配置示例
[Common]
Server=MetaQuotes-Demo        ; 服务器名称
Login=12345678                ; 账号
Password=your_password        ; 密码
; 或配置为自动交易模式
; TradeMode=1

[Tester]
Expert=MyEA                   ; EA名称（不含.ex5后缀）
ExpertParameters=MyEA.set     ; 参数文件
Symbol=EURUSD                 ; 交易品种
Period=H1                     ; 时间周期
FromDate=2024.01.01           ; 测试开始日期
ToDate=2024.12.31             ; 测试结束日期
Model=2                       ; 0=每笔报价, 1=1分钟OHLC, 2=仅开盘价
Deposit=10000                 ; 初始资金
Currency=USD                  ; 账户货币
Leverage=100                  ; 杠杆
Report=test_report            ; 报告文件名(自动加.htm)
Optimization=0                ; 0=单次测试, 1=优化
ShutdownTerminal=1            ; 测试完成后自动关闭终端

terminal64.exe /config:"C:\path\to\tester.ini"

风险：MT5命令行测试的配置项较多，不同版本的MT5可能存在参数差异。使用前请务必查阅MetaQuotes官方文档中对应版本的tester.ini配置说明，特别是Server、Login、Password这些认证信息的配置方式。另外，某些经纪商的MT5终端可能限制了命令行功能，如果遇到无法启动的情况，建议使用MetaQuotes官方版本的MT5终端来做自动化测试。

; MyEA.set —— 回归测试参数锁定文件
ATR_Period=14
ATR_Multiplier=2.0
Risk_Percent=1.0
Max_Spread=30
Magic_Number=123456
Use_Trailing_Stop=true
Trailing_Stop_Pips=50
Take_Profit_Ratio=1.5

操作建议：建议为你的EA维护多套.set文件，覆盖不同的测试场景：①基准测试集（baseline.set）——标准参数，用于快速验证核心功能是否正常；②极端参数集（extreme.set）——使用边界参数，验证鲁棒性；③多品种多周期集（多文件）——验证策略在不同市场环境下的行为一致性。把这些.set文件纳入版本管理（Git），每次代码提交后自动运行全部场景。

// 在EA中添加回归测试校验逻辑
// 这些代码只在测试模式下有意义，实盘中不影响

// 定义回归测试通过标准
struct RegressionCriteria
{
   double   maxDrawdownPercent;   // 最大回撤上限(%)
   double   minProfitFactor;      // 最小盈利因子
   int      minTrades;            // 最少交易次数
   int      maxTrades;            // 最多交易次数
   double   minSharpeRatio;       // 最小夏普比率
};

// 全局校验参数（可以通过.set文件配置）
input double   Reg_MaxDrawdown = 30.0;    // 最大回撤不超过30%
input double   Reg_MinProfitFactor = 1.2;  // 盈利因子不低于1.2
input int      Reg_MinTrades = 50;          // 交易次数不少于50笔
input int      Reg_MaxTrades = 5000;        // 交易次数不多于5000笔
input double   Reg_MinSharpe = 0.5;         // 夏普比率不低于0.5

// Tester事件：测试结束时执行
double OnTester()
{
   // 获取测试统计结果
   double totalNetProfit = TesterStatistics(STAT_PROFIT);
   double maxDrawdown = TesterStatistics(STAT_EQUITY_DDREL_PERCENT);
   double profitFactor = TesterStatistics(STAT_PROFIT_FACTOR);
   int totalTrades = (int)TesterStatistics(STAT_TRADES);
   double sharpe = TesterStatistics(STAT_SHARPE_RATIO);

   // 输出校验结果到日志
   Print("=== 回归测试校验 ===");
   Print("  净利润: $", DoubleToString(totalNetProfit, 2));
   Print("  最大回撤: ", DoubleToString(maxDrawdown, 2), "%");
   Print("  盈利因子: ", DoubleToString(profitFactor, 2));
   Print("  交易次数: ", totalTrades);
   Print("  夏普比率: ", DoubleToString(sharpe, 2));

   // 逐项校验
   bool allPassed = true;

   if(maxDrawdown > Reg_MaxDrawdown)
   {
      Print("  ✗ 失败: 最大回撤超标 (", maxDrawdown,
            "% > ", Reg_MaxDrawdown, "%)");
      allPassed = false;
   }
   else
      Print("  ✓ 通过: 最大回撤");

   if(profitFactor < Reg_MinProfitFactor)
   {
      Print("  ✗ 失败: 盈利因子不足 (", profitFactor,
            " < ", Reg_MinProfitFactor, ")");
      allPassed = false;
   }
   else
      Print("  ✓ 通过: 盈利因子");

   if(totalTrades < Reg_MinTrades)
   {
      Print("  ✗ 失败: 交易次数过少 (", totalTrades,
            " < ", Reg_MinTrades, ")");
      allPassed = false;
   }
   else if(totalTrades > Reg_MaxTrades)
   {
      Print("  ✗ 失败: 交易次数过多 (", totalTrades,
            " > ", Reg_MaxTrades, ")");
      allPassed = false;
   }
   else
      Print("  ✓ 通过: 交易次数");

   // 最终返回值：全部通过返回正数，失败返回负数
   if(allPassed)
   {
      Print("=== 全部校验通过 ===");
      return totalNetProfit;   // 通过时返回净利润作为排序依据
   }
   else
   {
      Print("=== 校验未通过 ===");
      return -1.0;             // 失败返回-1
   }
}

重点：OnTester()返回值的意义取决于你的使用场景。如果只是单次回归测试验证，用正数表示通过、负数表示失败就够了。如果你在做优化（Optimization=1），MT5会根据这个返回值对参数组合进行排序——返回值越大排名越高。这就是为什么很多人在OnTester()中返回净利润、夏普比率等指标的原因。注意：回归测试中使用OnTester()时，要确保Optimization=0，我们不需要优化参数，只需要验证固定参数下的行为一致性。

# regression_test.py —— 自动化回归测试脚本（核心逻辑示意）
import subprocess
import os
import time

def compile_ea(mql5_path, ea_name):
    """调用MetaEditor编译EA"""
    # metaeditor64.exe /compile:"路径" /log
    cmd = f'metaeditor64.exe /compile:"{mql5_path}\\Experts\\{ea_name}.mq5" /log'
    result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
    # 检查编译是否成功...
    return "0 error" in result.stdout

def run_backtest(terminal_path, ini_path, timeout=3600):
    """运行MT5回测"""
    cmd = f'"{terminal_path}" /config:"{ini_path}"'
    result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
    return result.returncode == 0

def check_report(log_path):
    """解析测试日志，判断回归测试是否通过"""
    with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
        content = f.read()
    # 检查OnTester输出的标记
    if "=== 全部校验通过 ===" in content:
        return True, "所有指标校验通过"
    elif "=== 校验未通过 ===" in content:
        return False, "部分指标未通过，请查看日志详情"
    else:
        return False, "未找到校验结果，测试可能未正常完成"

def main():
    ea_name = "MyEA"
    print(f"开始回归测试: {ea_name}")

    # 第1步：编译
    print("[1/3] 编译EA...")
    if not compile_ea(MQL5_PATH, ea_name):
        print("✗ 编译失败，终止测试")
        return False

    # 第二步：运行回测
    print("[2/3] 运行回测...")
    if not run_backtest(TERMINAL_PATH, TESTER_INI_PATH):
        print("✗ 回测运行失败")
        return False

    # 第三步：校验结果
    print("[3/3] 校验结果...")
    passed, msg = check_report(LOG_PATH)
    if passed:
        print(f"✓ 回归测试通过: {msg}")
    else:
        print(f"✗ 回归测试失败: {msg}")

    return passed

if __name__ == "__main__":
    success = main()
    exit(0 if success else 1)

进阶：如果你的团队已经有CI/CD流水线（如Jenkins、GitHub Actions等），可以把上面的回归测试脚本集成进去，实现"每次提交代码自动跑测试"。对于EA开发来说，由于MT5只能在Windows上运行，你需要一台Windows构建机器。另外，随着测试场景越来越多，回测时间会越来越长，这时候可以考虑引入分布式回测——把不同品种、不同周期的测试分配到多台机器上并行执行，大幅缩短整体测试时间。mcp-mt5等工具也可以帮助你在CI环境中更方便地控制MT5终端。

风险：自动化回归测试不是银弹，它有几个重要的局限性：①回测结果和实盘永远有差距，通过了回归测试不代表实盘一定没问题；②历史数据可能过拟合，如果你的测试集覆盖的市场形态不够丰富，回归测试可能给你虚假的安全感；③OnTester()中的校验指标需要精心设计，指标太松形同虚设，指标太紧又会误报。建议把自动化回归测试作为"质量门禁"而非"质量保证"，它能帮你拦住明显的退化，但不能保证策略的盈利能力。

概念：函数覆盖率（Function Coverage）：被测代码中有多少比例的函数被测试调用过。这是最粗粒度的覆盖率，只要函数被执行了就算覆盖，不管执行了多少行代码。分支覆盖率（Branch Coverage）：代码中有多少比例的分支（if/else、switch/case等）被测试走过了。比如一个if-else语句，只有if分支被执行了不算全覆盖，else分支也要被执行到才算。路径覆盖率（Path Coverage）：代码中所有可能的执行路径有多少被测试走过了。这是最严格的覆盖率，但对于包含循环和条件组合的代码，路径数量可能是指数级的，百分之百路径覆盖几乎不可能。

操作建议：在你的测试模块顶部维护一份"覆盖率自检清单"，格式如下：

✓ 已覆盖 / ✗ 未覆盖 + 函数名 + 分支点

例如：

✓ CalculateLotSize —— 正常输入

✓ CalculateLotSize —— ATR为0

✓ CalculateLotSize —— 风险比例为0

✓ CalculateLotSize —— 风险比例>百分之百

✓ CalculateLotSize —— 负余额

✓ CalculateLotSize —— 手数超上限截断

✓ CalculateLotSize —— 手数低于下限返回0

✗ CalculateLotSize —— lotStep为0的除零保护（待补充）

每次添加新测试或修改代码时更新这份清单，一目了然地知道哪些分支还没测。

重点：覆盖率不是越高越好，而是要"好钢用在刀刃上"。在EA开发中，建议遵循"核心模块高覆盖，边缘模块按需覆盖"的原则：①风控模块（止损止盈、仓位计算、风险控制）——覆盖率目标85%以上，因为这里出问题就是真金白银的损失；②信号计算模块（指标计算、信号判定）——覆盖率目标70%以上，确保核心计算逻辑正确；③辅助模块（日志、配置、工具函数）——覆盖率目标50%左右，覆盖主要路径即可；④UI交互和渲染逻辑——一般不做单元测试，靠手动验证即可。

风险：警惕"高覆盖率幻觉"。覆盖率高不代表测试质量高。举个例子：你写了一个测试，调用了一个函数，但里面一个断言都没有——函数确实执行了（覆盖率上去了），但根本没验证输出是否正确。这种"走过场式的测试"除了让覆盖率数字好看之外没有任何价值。永远记住：覆盖率是手段不是目的，写测试的目的是发现Bug，不是刷覆盖率数字。

进阶："微TDD"是一种轻量化的TDD实践，适合MQL5这样的非纯TDD生态。核心做法是：不追求"每个功能都先写测试"，而是针对"每个独立的计算函数"采用先写断言再写实现的节奏。具体步骤：①在测试文件里写下你期望的输入和输出（先写AssertDouble那行）；②编译（肯定报错，因为函数还没写或没实现）；③在业务文件中实现函数，直到编译通过且测试变绿；④如果需要，重构一下代码。每个循环5-15分钟，节奏轻快，不会有太大的心理负担。

操作建议：修复Bug是练习TDD的理想切入点。下次遇到Bug时，试试这个流程：①先不要急着改代码，而是写一个能复现这个Bug的测试用例；②运行测试，确认它失败了（这一步很重要——如果你写的测试都通过了，说明你写的测试不对，没有真正复现Bug）；③修复Bug代码；④再运行测试，确认它通过了。这样做有两个好处：一是确保Bug真正被修复了（不是你以为修好了），二是这个测试用例会永远留在测试集中，防止同样的Bug将来再次出现。一次Bug修复，换来一份永久的保险，性价比极高。

风险：不要神化TDD，也不要贬低TDD。TDD是一种开发方法论，不是宗教。它在某些场景下非常有效，在另一些场景下反而会拖慢节奏。EA开发中最合理的方式是"选择性TDD"——核心计算和风控模块用TDD确保质量，策略探索和原型阶段用快速迭代，两者结合使用，各取所长。不要因为别人说"TDD是推荐实践"就强迫自己所有代码都先写测试，也不要因为"TDD不适合EA"就彻底否定测试的价值。

进阶：7天落地行动清单

第1天：写下第1个断言

目标：跑通测试环境，理解断言的基本概念。

行动：①从本文复制TestCase.mqh到你的Include目录；②选一个你EA里最简单的纯计算函数（比如手数规范化、点值计算）；③写第1个测试用例，验证一个正常输入。运行测试，看到"通过"的输出。

第2天：补全边界条件测试

目标：学会边界值分析，完善第1个函数的测试覆盖。

行动：①为昨天的函数增加3-5个边界条件测试（0值、负数、极值、空值等）；②观察函数在边界条件下的行为是否符合预期；③如果发现Bug，修复它。

第3天：改造一个函数为参数注入

目标：掌握最基础的Mock方法，提升代码可测试性。

行动：①选一个EA中含有iCustom/SymbolInfo等外部调用的计算函数；②把它改造成参数注入形式，数据从外部传入；③为改造后的函数写3个以上测试用例。

第4天：为风控模块写完整测试

目标：系统地为一个核心模块搭建测试体系。

行动：①选择你EA中风控相关的类或模块（止损计算、仓位管理等）；②设计测试用例清单，覆盖正常、边界、异常三类场景；③编写8-10个测试用例，确保核心逻辑全覆盖。

第5天：搭建自动化回归测试

目标：实现一键回归测试，建立质量门禁。

行动：①准备一套基准参数的.set文件；②在EA中添加OnTester()校验逻辑，定义3-5个通过标准；③写一个简单的批处理或Python脚本，串联"编译→回测→查看结果"流程。

第6天：建立覆盖率自检清单

目标：量化测试覆盖情况，找出薄弱环节。

行动：①列出EA中所有核心函数和关键分支；②逐一检查哪些已经有测试、哪些还没有；③补充3-5个之前遗漏的重要测试；④把清单保存到测试文件顶部，作为长期维护的依据。

第7天：用TDD方式修一个Bug

目标：体验测试驱动开发的实际价值。

行动：①找一个已知的Bug（或自己造一个简单的）；②先写一个能复现Bug的测试用例，确认测试失败；③修复Bug，确认测试通过；④体验一下"有测试兜底，改代码有底气"的感觉。

完成这7步，你的EA就拥有了一套基本完善的质量保障体系。更重要的是，你已经建立了"测试思维"——以后写代码时，会自然而然地考虑"这段代码好不好测""这个逻辑怎么验证"，这才是最宝贵的收获。

风险提示：本文所介绍的单元测试方法和自动化QA技术旨在提升代码质量与开发效率，所有代码示例仅供学习研究使用，不构成任何投资建议或交易策略推荐。金融市场交易存在亏损风险，任何EA或策略的历史表现均不代表未来收益。读者应在充分理解代码逻辑和交易风险的前提下自行决策，谨慎使用。本文作者及晓辉编程不对因使用本文内容而导致的任何直接或间接损失承担责任。

第三方免责声明：本文中提及的MQL5Unit、MQLUNIT、MetaTrader 5等第三方框架和工具，其商标及知识产权归各自所有者所有。本文仅作技术介绍和学习交流使用，不构成对任何第三方产品的官方推荐或背书。读者在使用第三方工具时，请自行评估其适用性和安全性，并遵守相应的使用许可协议。本站定位为软件开发与技术服务类网站，专注于MQL5编程技术分享与EA定制开发服务。

获取完整测试框架源码与更多EA开发干货

关注公众号回复「测试框架」获取本文完整源码包