}fO&rbF+T#6)JP4l(0W%jKq#<5ZG
zJ$mKQM^|6-kuuU@LR<7rlwrcDNq_G1dF7%YHxdp%NJuf!k9I&7VPflLhuAeXS=>Xm
zzDt|7@?~{qQAN)=#;)rPPS2zkRZnm#T@bHd^uHl{Bv#&4AUrW+`V{%G#CyD^SO0C?_SfFy;0l$bH@c0#`-t3ye0V
z?8iDAdW-ivBu+`B*XPC)CfGIVhZ)?W&YK1F)&JS=k=5KM@%E{bxv{1)5fUym*yW;gTdisLJCUELJpN2ZDvo}^+%2Gu7=Y>sMI*z;7m
z;%xmT%@aPBmU)vM*kwc8rhWf-NtQZarTTG0^&1?Db)iR8G6WUMO{AfRX_H$ClXO~T
zJ~CQ%QN|IrNqNx6)66)tII;0zz=of0xbRqQIM74hJD;`rMwwVCYM9b6hP;<@C6d%s
z`)c5lTMHB^nou37C&%e0Cw6c6kaAIM(1LBfntNd=JH+kVMpxEUUqg&4&q$ygpZ_VO
z-zyu-DtITzVMTvr`(!V3+rt)A`mKMh=mQO1dWSO9wk1!FWGdKGlpi10g>Cv3URCii
zdaJi=Aw99@i@dztz&QR0BOROl%9=@FV7fOWFZN^=;f>I=!B1D*SOZS4IZELM^8eRNYlHS
zCrFIR0RcBoWi);5bL!Eo;ASYN5iLoKqq=)s_`AdY-M7(K(|7Jffw%W0UC7hoFb@?j
zxt-sAh1OG^j=I3js!dxTgcP%
zfie{8t1|Yo-Bh18NA1)EP84I7KbZ=9I$!Wa+{zr0KN@HmQqX3XttG2@2drlpN~LQf
z0WXgOBFVW^N;o@Be&z>wcs2P_a^z?fVeu?tmR{a?F~h``x_!mdWKDZ%vAJ6pvx(Na
zU5HTAZJ>2F<=izg6(vQ3?1a#w$v0;a#^nCgglFYBgUovZ08BF{&3xv#a`yIc>_ATL
z*7?}W#gT+`LW7-fbNzYAhM#a+yLmV5N6rDlo~_;b&_>WQ=&qaUt*2RO#Lze)%ZvFH
z`strzD|YHLmP3x%*imL^Y1J_SD4+GQVk&j=X53MSh
ze^!?v_B)jVFTR)tI;$m|oGi+%e4u%0;^f{U``*~$tE47e;#Q)hXE)CTCxrUGaJgGi
z+qheIlz#3Z_rSVB9p$bt=^HP9lG#Mx$82t1mE~q|RDba(}=?_!m#f
zN&Bnh766T1w`dPr%Jj#GIzxx`u?iy3l+UK)4gs&{p4{`v4b24gNDQPDQOTKnEzyz7
zDZe^i?!Wo)m?`#Ts?zb~)z4j?*tkuBm_;zqFCwW*Am4MbYhA1+)47`Qb0sHdfu;j+
z_t)*|6SaQQ!EvSA`!n19R{#?nIwV=>T1pog)0qA=L0-rybhLs*iw0kKe_KyOSWF6M
z5QM*}#Ab0veqIW+osRHR3ohg7MA4$sL`*YSCaFH%s!_5-+*HF&l4w4s#cUGKxb^rW
z;6(4V&KS5ojc~$6nX`5!!etUVW?-hz3W#Gq?tZLs%WJ@J$rGpdnFvm)l!
zFi+0;g+&@V_0vZ!wI~Po7V2AUY!R!8`N4Jr8@g(83};`ZRy=uf2|0*}TmQ%e!Xn{;
z*Nm}*6t~+1j~o`4pO(sLyEU+$jOpOw!V@Mh0>(jQV1K5DQ>c
zL6XK02Ek38H1JWE5T3}9cxz_ZV0t5}`-h$1iOo+1D~~X5PlDh=ik?^BvZ&R2K@zQm
zoAs+)!XBz+rx;TF0zKP)m4;0PqA1Bv*f-3qG^4SjG|x8b;jxpOvnnOVQHy&ij2Y8*
z%8k#H-RD+#47>R55i72RmKE8~iq71XT7$4qo7485khWEaEvp}WDbn~{!Zq
zq}}pnX-whM#Ez`*`DMR|O}I=#v-D2a#mn4>ZWsjX*L{j?78JBImqPHqN4%K^Ai)0i
z7UqWn<FjD6~56j@Gw0Lu?LX77+
z)XVcLxKNUJV0oHb0-fZ_nRK%!e=V213e8Vf%rdA4oVvr;%^b_&TBjw9-g+ExR_W_z
zOVLDub98sT%9SJ_%FKP{`DIvOE4f1;{eHRFFM^Sp|3D9Nm)ous=QEmh8;j(W%xLLq
zPg0HPI>7Xe=F_8S)zZ$D9F_m6)*S)59GjyXdaDrG0*io!oUAH(Ya!~bip$4H%l7M_
zICmkBe31EDA@NuG5syFDLIGT1Md&$?t_oci_%_TOA+GYj=_}Ge?R%zH`2l!I^=X%F
zgMlTt++#bZikQTl*ZRfvEH-5B&>!|n$J|`(30{=Rc3s}e(UIx-`|(6TM#K2`9Odj0
zl%H`I!Zm>lc><`jU)q3tX0@AChOx*q5g+%H{2t@?M%(kPgh`wNHLn~wE!2T!;y-R+
z_6<+`pexiW6U;&H0ol2*95%VK_wNiFJj`|2v5YVW!>7+{oa=>+-Y59cD+m~2ugoh+
zMOd^I4xjYJxTzIf7||`SpMCCiOnUQxZqGHTj=g5p@Q8O%PcRMN-tVypdI{gYZHx3&
zo(#UZp#8yqPHVNaV|Pz-Uy4#)ZIaRV!NAr^Egdzt=yQhYCYl6G)jqJPaAvSsR|QH|
z({85FbC4+K3tcx<@NV9-_xtnORXPAJwk*meWqe?z;HzBPnSY)&?`4o3ID~zYcjdFX
zlSo96b$8-H7c7Ni3ll>!*uR3bG}-oRPJNA|L}@v}njgT$SOM|aL-ogs#ES}0D^M&C
zkvVq*FUR)tE}$`s^sRuLK^1z^{097%0G=ylBRJfj*mC$0EBryB&X3_)sl`E*=B3yW
zs_PQn_s5Ji|55h*XPR3b@ogti$8=>vfBT*_UrKRV3s#9P=I$hmE-=l3PZT>z(FtuA{Me^jG_#MgkYW*
zmQXv1KC#<*%!EdqPs^KD{3_AV-FBbK%gECKQ9Vza5kd>CZj_>60+AnPqsTW~icDl^|fWWmb7K58J?0nSKkS&qthOU;+;wSZc}(
zgl{r`an}WLXp29aj;@fv5rxfmUcBxbJ(MIV(wYK2FnxTRn_&TnGtboCFuXTkb!)Gb
z(qt8@5qASl=h&XILu*;@^4Ay4KdY=@3Nnp?EC-Koa}1m%#JX1
zfJH%bx${J6)l%6tY2KB(`e0JYpimQo`JC2yg!~w&j-6>W`JqS84CyM;_?cuoR7&c5
z@j8>>i>IH~hx=zY7HtiN?VO+`?4RQj!C?V=_8u^$Z1UJ~3`@B>_yTXwKzgDu(rIOz
z9(-$q6BNgPuIYvqmBox6oz!{gbh~`5?Zs~EjSCgnwm)yFbo@=b_GW8gQtl9Dpo^3f
zy0ckwl3q#TH5fn!^reudm_-=Tr`FtI+-Q5`(&wUPvua_8lXS$&eW$OQLRoQu?tGQ6
zRSRIalu!4##fciCjMmCBh@+wp&*h?vfvq#D>9c^NgQR^~fA+gJBifR9!S6xd;L>5v
z$F)}$Jo*j2#q2ThE-g)BT*+yVk~^QfZ#N!OF|l!cm>0|mjX?;5XuxsM2jSohd{J~6U9W>9AMy1M#OUq?&+(6wh?8(stPzKA
z-RDrz6fAZO)6nz8MX^4PdI>krGBa$x=)h2{991u?d{8;0sL+@BsU`LNQk%n(Qu_$Fh-Qdc1AT`FI9PEtz*GPhLoT^_Ez#k2mBOH+~I
zzCEFnuC}&5IeT{L?cXtnV56K6Het!PW-%=(a|wK@^mEGX`nQ!+$xN6=?R7=ZAAg`}
zZ?i-}@k<+c8_xt+b@wOFJ^-iV)F}{5h`v>XG%<~)@MRh`)p!`0jcD&nMyE5HxsoFn
zJ>^Xjm>wG@YSC_TF};`;m-qs$vDff{_0@{_@^p69HBQbLnB+CT$G)wlkOGA&fTSa1
zG|ccha()=BcBtum{^`O;&dZ*;?{ll&WVbJ`^dPb%vlsvf36>?bI-$8SC1!LpXh`)z
zEG&A1R8Ct|bU*IjR`XE(sYG_HQ
zv9W=gmQ#DNu8tOde&ST9c>{Ru>G&3t28uUNz%3+=v$VF;kx^Q{
zZ2Kj~k8|m+&X5bbU)s1HVBz#{iH+HHk58HG&ZO%efiD?37M{sJ3rfd9(AT82xYx?|
z{ic`t#M{4bPmC3F9J*{|XL0exDbO)}H4!ZFl2=7-a+aEF+fWr`Ur$TW6Z#VqCptsX
xYT+dA*+o!f_gS9fC^!`OZG{z%9hyC^4hHV&ikN+r5+ooTz?OV`wC~06`wtm& 0)
- {
- // Verify data reaches all detectors
- m_ob_detector.UpdateMarketData(rates);
- m_bos_detector.UpdateMarketData(rates);
- m_ls_detector.UpdateMarketData(rates);
- m_fvg_detector.UpdateMarketData(rates);
-
- // Test data integrity
- SOrderBlock order_blocks[];
- m_ob_detector.DetectOrderBlocks(order_blocks);
-
- test_passed = (ArraySize(order_blocks) >= 0);
- }
- else
- {
- test_passed = false;
- }
- }
- catch(...)
- {
- test_passed = false;
- }
-
- double execution_time = GetExecutionTime(start_time);
-
- SDataFlowTest result;
- result.flow_name = "Market Data Flow";
- result.data_integrity_passed = test_passed;
- result.timing_passed = (execution_time < 1000); // Less than 1 second
- result.dependency_passed = test_passed;
- result.latency_ms = execution_time;
- result.error_details = test_passed ? "" : "Data flow failed";
-
- int size = ArraySize(m_dataflow_results);
- ArrayResize(m_dataflow_results, size + 1);
- m_dataflow_results[size] = result;
-
- PrintTestProgress("Market Data Flow", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Signal Data Flow |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestSignalDataFlow()
-{
- Print("Testing Signal Data Flow...");
-
- datetime start_time = TimeCurrent();
- bool test_passed = true;
-
- try
- {
- // Test signal flow from detectors to entry strategy
- SEntrySignal entry_signal;
- bool signal_generated = m_entry_strategy.AnalyzeEntry(entry_signal);
-
- if(signal_generated)
- {
- // Test signal flow to risk manager
- STradeRequest trade_request;
- bool risk_validated = m_risk_manager.ValidateAndPrepareOrder(entry_signal, trade_request);
-
- // Test signal flow to session manager
- bool session_allowed = m_session_manager.AllowTrade(entry_signal);
-
- test_passed = risk_validated && session_allowed;
- }
- }
- catch(...)
- {
- test_passed = false;
- }
-
- double execution_time = GetExecutionTime(start_time);
-
- SDataFlowTest result;
- result.flow_name = "Signal Data Flow";
- result.data_integrity_passed = test_passed;
- result.timing_passed = (execution_time < 500); // Less than 0.5 seconds
- result.dependency_passed = test_passed;
- result.latency_ms = execution_time;
- result.error_details = test_passed ? "" : "Signal flow failed";
-
- int size = ArraySize(m_dataflow_results);
- ArrayResize(m_dataflow_results, size + 1);
- m_dataflow_results[size] = result;
-
- PrintTestProgress("Signal Data Flow", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Risk Data Flow |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestRiskDataFlow()
-{
- Print("Testing Risk Data Flow...");
-
- datetime start_time = TimeCurrent();
- bool test_passed = true;
-
- try
- {
- // Test risk data flow
- STradeRequest trade_request;
- trade_request.symbol = TestSymbol;
- trade_request.type = ORDER_TYPE_BUY;
- trade_request.entry_price = SymbolInfoDouble(TestSymbol, SYMBOL_ASK);
- trade_request.stop_loss = trade_request.entry_price - 50 * SymbolInfoDouble(TestSymbol, SYMBOL_POINT);
-
- // Test position size calculation
- double position_size = m_risk_manager.CalculatePositionSize(trade_request);
-
- // Test risk validation
- bool risk_valid = m_risk_manager.ValidateRisk(trade_request);
-
- test_passed = (position_size > 0 && risk_valid);
- }
- catch(...)
- {
- test_passed = false;
- }
-
- double execution_time = GetExecutionTime(start_time);
-
- SDataFlowTest result;
- result.flow_name = "Risk Data Flow";
- result.data_integrity_passed = test_passed;
- result.timing_passed = (execution_time < 100); // Less than 0.1 seconds
- result.dependency_passed = test_passed;
- result.latency_ms = execution_time;
- result.error_details = test_passed ? "" : "Risk flow failed";
-
- int size = ArraySize(m_dataflow_results);
- ArrayResize(m_dataflow_results, size + 1);
- m_dataflow_results[size] = result;
-
- PrintTestProgress("Risk Data Flow", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Visualization Data Flow |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestVisualizationDataFlow()
-{
- Print("Testing Visualization Data Flow...");
-
- datetime start_time = TimeCurrent();
- bool test_passed = true;
-
- try
- {
- // Test visualization updates
- SPerformanceMetrics metrics;
- metrics.total_trades = 5;
- metrics.winning_trades = 3;
- metrics.net_profit = 500.0;
- metrics.win_rate = 0.6;
-
- bool display_updated = m_chart_manager.UpdatePerformanceDisplay(metrics);
- test_passed = display_updated;
- }
- catch(...)
- {
- test_passed = false;
- }
-
- double execution_time = GetExecutionTime(start_time);
-
- SDataFlowTest result;
- result.flow_name = "Visualization Data Flow";
- result.data_integrity_passed = test_passed;
- result.timing_passed = (execution_time < 200); // Less than 0.2 seconds
- result.dependency_passed = test_passed;
- result.latency_ms = execution_time;
- result.error_details = test_passed ? "" : "Visualization flow failed";
-
- int size = ArraySize(m_dataflow_results);
- ArrayResize(m_dataflow_results, size + 1);
- m_dataflow_results[size] = result;
-
- PrintTestProgress("Visualization Data Flow", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Component Dependencies |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestComponentDependencies()
-{
- Print("Testing Component Dependencies...");
-
- // Test that components can work independently and together
- bool test_passed = true;
-
- // Test individual component functionality
- if(!m_ob_detector.IsInitialized()) test_passed = false;
- if(!m_risk_manager.IsInitialized()) test_passed = false;
- if(!m_session_manager.IsInitialized()) test_passed = false;
-
- PrintTestProgress("Component Dependencies", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Event Handling |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestEventHandling()
-{
- Print("Testing Event Handling...");
-
- // Test event propagation between components
- bool test_passed = true;
-
- // Simulate market events and verify handling
- // This would test OnTick, OnTimer, etc. event handling
-
- PrintTestProgress("Event Handling", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Memory Management |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestMemoryManagement()
-{
- Print("Testing Memory Management...");
-
- // Test for memory leaks and proper cleanup
- bool test_passed = true;
-
- // Create and destroy components multiple times
- for(int i = 0; i < 10; i++)
- {
- COrderBlockDetector* temp_detector = new COrderBlockDetector();
- temp_detector.Initialize(TestSymbol, TestTimeframe);
- delete temp_detector;
- }
-
- PrintTestProgress("Memory Management", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Thread Safety |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestThreadSafety()
-{
- Print("Testing Thread Safety...");
-
- // Test concurrent access to components
- bool test_passed = true;
-
- // In MT5, this would test timer events vs tick events
-
- PrintTestProgress("Thread Safety", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test System Latency |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestSystemLatency()
-{
- Print("Testing System Latency...");
-
- datetime start_time = TimeCurrent();
-
- // Test end-to-end latency
- SEntrySignal entry_signal;
- bool signal_generated = m_entry_strategy.AnalyzeEntry(entry_signal);
-
- double latency = GetExecutionTime(start_time);
- bool test_passed = (latency < 100); // Less than 100ms
-
- PrintTestProgress("System Latency", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Memory Usage |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestMemoryUsage()
-{
- Print("Testing Memory Usage...");
-
- // Test memory consumption
- bool test_passed = true;
-
- // Monitor memory usage during operations
- // This is platform-specific and may not be directly available in MT5
-
- PrintTestProgress("Memory Usage", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test CPU Usage |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestCPUUsage()
-{
- Print("Testing CPU Usage...");
-
- // Test CPU efficiency
- bool test_passed = true;
-
- datetime start_time = TimeCurrent();
-
- // Perform intensive operations
- for(int i = 0; i < 1000; i++)
- {
- SEntrySignal entry_signal;
- m_entry_strategy.AnalyzeEntry(entry_signal);
- }
-
- double execution_time = GetExecutionTime(start_time);
- test_passed = (execution_time < 5000); // Less than 5 seconds for 1000 operations
-
- PrintTestProgress("CPU Usage", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Invalid Input Handling |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestInvalidInputHandling()
-{
- Print("Testing Invalid Input Handling...");
-
- bool test_passed = true;
-
- try
- {
- // Test with invalid symbol
- bool invalid_init = m_ob_detector.Initialize("INVALID", TestTimeframe);
- if(invalid_init) test_passed = false; // Should fail
-
- // Test with invalid parameters
- STradeRequest invalid_request;
- invalid_request.symbol = "";
- invalid_request.entry_price = -1.0;
-
- bool invalid_risk = m_risk_manager.ValidateRisk(invalid_request);
- if(invalid_risk) test_passed = false; // Should fail
- }
- catch(...)
- {
- // Exceptions are expected for invalid inputs
- }
-
- PrintTestProgress("Invalid Input Handling", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Network Error Handling |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestNetworkErrorHandling()
-{
- Print("Testing Network Error Handling...");
-
- bool test_passed = true;
-
- // Test AI component with invalid API credentials
- CGrokAI* test_ai = new CGrokAI();
- bool invalid_init = test_ai.Initialize("invalid_key", "invalid_url");
-
- // Should handle gracefully without crashing
- SFundamentalAnalysis analysis;
- bool analysis_ok = test_ai.GetFundamentalAnalysis(TestSymbol, analysis);
-
- // Should fail gracefully
- if(analysis_ok && invalid_init) test_passed = false;
-
- delete test_ai;
-
- PrintTestProgress("Network Error Handling", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Memory Error Handling |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestMemoryErrorHandling()
-{
- Print("Testing Memory Error Handling...");
-
- bool test_passed = true;
-
- // Test large array allocations
- try
- {
- MqlRates large_array[];
- ArrayResize(large_array, 1000000); // Large allocation
- ArrayFree(large_array);
- }
- catch(...)
- {
- // Should handle memory errors gracefully
- }
-
- PrintTestProgress("Memory Error Handling", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Recovery Mechanisms |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::TestRecoveryMechanisms()
-{
- Print("Testing Recovery Mechanisms...");
-
- bool test_passed = true;
-
- // Test component recovery after errors
- // Simulate error conditions and test recovery
-
- PrintTestProgress("Recovery Mechanisms", test_passed);
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Initialize Test Environment |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::InitializeTestEnvironment()
-{
- Print("Initializing test environment...");
-
- // Clear any existing test data
- ArrayFree(m_test_results);
- ArrayFree(m_dataflow_results);
-
- // Verify symbol availability
- if(!SymbolSelect(TestSymbol, true))
- {
- Print("Failed to select symbol: ", TestSymbol);
- return false;
- }
-
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Load Test Data |
-//+------------------------------------------------------------------+
-bool CIntegrationTest::LoadTestData()
-{
- Print("Loading test data...");
-
- // Load historical data for testing
- int copied = CopyRates(TestSymbol, TestTimeframe, 0, TestBars, m_test_rates);
-
- if(copied < TestBars)
- {
- Print("Warning: Only ", copied, " bars copied instead of ", TestBars);
- }
-
- return (copied > 0);
-}
-
-//+------------------------------------------------------------------+
-//| Cleanup Test Environment |
-//+------------------------------------------------------------------+
-void CIntegrationTest::CleanupTestEnvironment()
-{
- // Clean up test data
- ArrayFree(m_test_rates);
- ArrayFree(m_test_results);
- ArrayFree(m_dataflow_results);
-
- // Remove test objects from chart
- if(m_chart_manager != NULL)
- {
- m_chart_manager.ClearAllObjects();
- }
-}
-
-//+------------------------------------------------------------------+
-//| Create Test Result |
-//+------------------------------------------------------------------+
-SIntegrationTestResult CIntegrationTest::CreateTestResult(string component, bool passed, double time_ms, string error = "")
-{
- SIntegrationTestResult result;
- result.component_name = component;
- result.initialization_passed = passed;
- result.functionality_passed = passed;
- result.integration_passed = passed;
- result.performance_passed = (time_ms < 1000); // Less than 1 second
- result.error_handling_passed = passed;
- result.execution_time_ms = time_ms;
- result.error_message = error;
- result.test_score = passed ? 100 : 0;
-
- return result;
-}
-
-//+------------------------------------------------------------------+
-//| Print Test Progress |
-//+------------------------------------------------------------------+
-void CIntegrationTest::PrintTestProgress(string test_name, bool passed)
-{
- string status = passed ? "โ
PASSED" : "โ FAILED";
- Print(" ", test_name, ": ", status);
-}
-
-//+------------------------------------------------------------------+
-//| Get Execution Time |
-//+------------------------------------------------------------------+
-double CIntegrationTest::GetExecutionTime(datetime start_time)
-{
- return (double)(TimeCurrent() - start_time) * 1000.0; // Convert to milliseconds
-}
-
-//+------------------------------------------------------------------+
-//| Generate Integration Report |
-//+------------------------------------------------------------------+
-void CIntegrationTest::GenerateIntegrationReport()
-{
- Print("");
- Print("=== Generating Integration Test Report ===");
-
- string filename = "SniperEA_IntegrationReport_" + TestSymbol + "_" +
- TimeToString(TimeCurrent(), TIME_DATE) + ".csv";
-
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_CSV);
-
- if(file_handle != INVALID_HANDLE)
- {
- // Write header
- FileWrite(file_handle, "Component", "Initialization", "Functionality", "Integration",
- "Performance", "Error Handling", "Execution Time (ms)", "Score", "Error Message");
-
- // Write test results
- for(int i = 0; i < ArraySize(m_test_results); i++)
- {
- SIntegrationTestResult& result = m_test_results[i];
- FileWrite(file_handle,
- result.component_name,
- result.initialization_passed ? "PASS" : "FAIL",
- result.functionality_passed ? "PASS" : "FAIL",
- result.integration_passed ? "PASS" : "FAIL",
- result.performance_passed ? "PASS" : "FAIL",
- result.error_handling_passed ? "PASS" : "FAIL",
- DoubleToString(result.execution_time_ms, 2),
- result.test_score,
- result.error_message);
- }
-
- // Write data flow results
- FileWrite(file_handle, "", "", "", "", "", "", "", "", "");
- FileWrite(file_handle, "DATA FLOW TESTS", "", "", "", "", "", "", "", "");
- FileWrite(file_handle, "Flow Name", "Data Integrity", "Timing", "Dependencies",
- "Latency (ms)", "", "", "", "Error Details");
-
- for(int i = 0; i < ArraySize(m_dataflow_results); i++)
- {
- SDataFlowTest& result = m_dataflow_results[i];
- FileWrite(file_handle,
- result.flow_name,
- result.data_integrity_passed ? "PASS" : "FAIL",
- result.timing_passed ? "PASS" : "FAIL",
- result.dependency_passed ? "PASS" : "FAIL",
- DoubleToString(result.latency_ms, 2),
- "", "", "",
- result.error_details);
- }
-
- FileClose(file_handle);
- Print("Integration test report saved to: ", filename);
- }
- else
- {
- Print("Failed to save integration test report");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Script start function |
-//+------------------------------------------------------------------+
-void OnStart()
-{
- Print("Starting MT5 Sniper EA Integration Tests...");
- Print("This will verify that all components work together correctly.");
- Print("");
-
- CIntegrationTest* integration_test = new CIntegrationTest();
-
- bool success = integration_test.RunIntegrationTests();
-
- if(success)
- {
- Print("");
- Print("๐ฏ All integration tests passed successfully!");
- Print("The EA components are properly integrated and working together.");
- }
- else
- {
- Print("");
- Print("โ ๏ธ Some integration tests failed. Please check the detailed report.");
- }
-
- delete integration_test;
-
- Print("Integration testing completed.");
-}
\ No newline at end of file
diff --git a/src/Tests/NewsSystemTest.mq5 b/src/Tests/NewsSystemTest.mq5
deleted file mode 100644
index 9a222ef..0000000
--- a/src/Tests/NewsSystemTest.mq5
+++ /dev/null
@@ -1,702 +0,0 @@
-//+------------------------------------------------------------------+
-//| NewsSystemTest.mq5 |
-//| Copyright 2024, MetaQuotes Ltd. |
-//| https://www.mql5.com |
-//+------------------------------------------------------------------+
-#property copyright "Copyright 2024, MetaQuotes Ltd."
-#property link "https://www.mql5.com"
-#property version "1.00"
-#property script_show_inputs
-
-//--- Include test framework and news system components
-#include "../Include/Utils/Logger.mqh"
-#include "../Include/Utils/NewsManager.mqh"
-#include "../Include/Utils/FundamentalAnalysis.mqh"
-#include "../Include/Utils/NewsFilter.mqh"
-
-//--- Test parameters
-input bool EnableDetailedLogging = true;
-input bool TestNewsManager = true;
-input bool TestFundamentalAnalysis = true;
-input bool TestNewsFilter = true;
-input bool TestIntegration = true;
-
-//--- Global test variables
-CLogger* g_testLogger;
-CNewsManager* g_newsManager;
-CFundamentalAnalysis* g_fundamentalAnalysis;
-CNewsFilter* g_newsFilter;
-
-int g_totalTests = 0;
-int g_passedTests = 0;
-int g_failedTests = 0;
-
-//+------------------------------------------------------------------+
-//| Script program start function |
-//+------------------------------------------------------------------+
-void OnStart() {
- Print("=== NEWS SYSTEM COMPREHENSIVE TEST SUITE ===");
- Print("Starting news avoidance and fundamental analysis tests...");
-
- // Initialize test environment
- if(!InitializeTestEnvironment()) {
- Print("ERROR: Failed to initialize test environment");
- return;
- }
-
- // Run test suites
- if(TestNewsManager) RunNewsManagerTests();
- if(TestFundamentalAnalysis) RunFundamentalAnalysisTests();
- if(TestNewsFilter) RunNewsFilterTests();
- if(TestIntegration) RunIntegrationTests();
-
- // Generate test report
- GenerateTestReport();
-
- // Cleanup
- CleanupTestEnvironment();
-
- Print("=== NEWS SYSTEM TEST SUITE COMPLETED ===");
-}
-
-//+------------------------------------------------------------------+
-//| Initialize test environment |
-//+------------------------------------------------------------------+
-bool InitializeTestEnvironment() {
- g_testLogger = new CLogger();
- if(g_testLogger == NULL) return false;
- g_testLogger.Initialize(EnableDetailedLogging, LOG_LEVEL_DEBUG);
-
- g_newsManager = new CNewsManager();
- g_fundamentalAnalysis = new CFundamentalAnalysis();
- g_newsFilter = new CNewsFilter();
-
- if(g_newsManager == NULL || g_fundamentalAnalysis == NULL || g_newsFilter == NULL) {
- return false;
- }
-
- // Initialize components
- if(!g_newsManager.Initialize()) return false;
- if(!g_fundamentalAnalysis.Initialize()) return false;
- if(!g_newsFilter.Initialize()) return false;
-
- g_testLogger.Info("Test environment initialized successfully");
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Run News Manager Tests |
-//+------------------------------------------------------------------+
-void RunNewsManagerTests() {
- Print("\n--- TESTING NEWS MANAGER ---");
-
- // Test 1: News Event Management
- TestNewsEventManagement();
-
- // Test 2: High Impact News Detection
- TestHighImpactNewsDetection();
-
- // Test 3: Trading Restrictions
- TestTradingRestrictions();
-
- // Test 4: Emergency Controls
- TestEmergencyControls();
-
- // Test 5: Data Updates
- TestNewsDataUpdates();
-}
-
-//+------------------------------------------------------------------+
-//| Test News Event Management |
-//+------------------------------------------------------------------+
-void TestNewsEventManagement() {
- string testName = "News Event Management";
- g_totalTests++;
-
- try {
- // Add test news event
- SNewsEvent testEvent;
- testEvent.title = "Test NFP Release";
- testEvent.currency = "USD";
- testEvent.impact = NEWS_IMPACT_HIGH;
- testEvent.type = NEWS_TYPE_EMPLOYMENT;
- testEvent.releaseTime = TimeCurrent() + 3600; // 1 hour from now
- testEvent.isActive = true;
-
- bool added = g_newsManager.AddNewsEvent(testEvent);
-
- // Check if event was added
- SNewsEvent retrievedEvents[];
- int count = g_newsManager.GetUpcomingNews(retrievedEvents, 24);
-
- bool found = false;
- for(int i = 0; i < count; i++) {
- if(retrievedEvents[i].title == "Test NFP Release") {
- found = true;
- break;
- }
- }
-
- if(added && found) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Event not properly managed");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test High Impact News Detection |
-//+------------------------------------------------------------------+
-void TestHighImpactNewsDetection() {
- string testName = "High Impact News Detection";
- g_totalTests++;
-
- try {
- // Add high impact news event for current time
- SNewsEvent highImpactEvent;
- highImpactEvent.title = "Test High Impact Event";
- highImpactEvent.currency = "USD";
- highImpactEvent.impact = NEWS_IMPACT_HIGH;
- highImpactEvent.type = NEWS_TYPE_MONETARY_POLICY;
- highImpactEvent.releaseTime = TimeCurrent();
- highImpactEvent.isActive = true;
-
- g_newsManager.AddNewsEvent(highImpactEvent);
-
- // Test detection
- bool isHighImpactTime = g_newsManager.IsHighImpactNewsTime();
-
- if(isHighImpactTime) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - High impact news not detected");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Trading Restrictions |
-//+------------------------------------------------------------------+
-void TestTradingRestrictions() {
- string testName = "Trading Restrictions";
- g_totalTests++;
-
- try {
- // Set trading restriction
- STradingRestriction restriction;
- restriction.startTime = TimeCurrent();
- restriction.endTime = TimeCurrent() + 1800; // 30 minutes
- restriction.reason = "Test Restriction";
- restriction.isActive = true;
-
- g_newsManager.SetTradingRestriction(restriction);
-
- // Test if trading is restricted
- bool isRestricted = g_newsManager.IsTradingRestricted();
-
- if(isRestricted) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Trading restriction not applied");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Emergency Controls |
-//+------------------------------------------------------------------+
-void TestEmergencyControls() {
- string testName = "Emergency Controls";
- g_totalTests++;
-
- try {
- // Test emergency stop
- g_newsManager.ActivateEmergencyStop("Test Emergency");
-
- bool isEmergencyActive = g_newsManager.IsEmergencyStopActive();
-
- if(isEmergencyActive) {
- // Test deactivation
- g_newsManager.DeactivateEmergencyStop();
- bool isStillActive = g_newsManager.IsEmergencyStopActive();
-
- if(!isStillActive) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Emergency stop not deactivated");
- }
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Emergency stop not activated");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test News Data Updates |
-//+------------------------------------------------------------------+
-void TestNewsDataUpdates() {
- string testName = "News Data Updates";
- g_totalTests++;
-
- try {
- // Test data update functionality
- datetime lastUpdate = g_newsManager.GetLastUpdateTime();
-
- g_newsManager.UpdateNewsData();
-
- datetime newUpdateTime = g_newsManager.GetLastUpdateTime();
-
- if(newUpdateTime >= lastUpdate) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Data not updated");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Run Fundamental Analysis Tests |
-//+------------------------------------------------------------------+
-void RunFundamentalAnalysisTests() {
- Print("\n--- TESTING FUNDAMENTAL ANALYSIS ---");
-
- // Test 1: Factor Management
- TestFactorManagement();
-
- // Test 2: Impact Analysis
- TestImpactAnalysis();
-
- // Test 3: Currency Strength Analysis
- TestCurrencyStrengthAnalysis();
-
- // Test 4: Trading Avoidance Logic
- TestTradingAvoidanceLogic();
-}
-
-//+------------------------------------------------------------------+
-//| Test Factor Management |
-//+------------------------------------------------------------------+
-void TestFactorManagement() {
- string testName = "Factor Management";
- g_totalTests++;
-
- try {
- // Add test fundamental factor
- SFundamentalFactor testFactor;
- testFactor.name = "Test Interest Rate";
- testFactor.category = INDICATOR_MONETARY_POLICY;
- testFactor.currency = "USD";
- testFactor.currentValue = 5.25;
- testFactor.previousValue = 5.00;
- testFactor.expectedValue = 5.50;
- testFactor.impact = IMPACT_HIGH;
- testFactor.lastUpdate = TimeCurrent();
-
- bool added = g_fundamentalAnalysis.AddFactor(testFactor);
-
- // Retrieve and verify
- SFundamentalFactor retrievedFactors[];
- int count = g_fundamentalAnalysis.GetFactorsByCurrency("USD", retrievedFactors);
-
- bool found = false;
- for(int i = 0; i < count; i++) {
- if(retrievedFactors[i].name == "Test Interest Rate") {
- found = true;
- break;
- }
- }
-
- if(added && found) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Factor not properly managed");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Impact Analysis |
-//+------------------------------------------------------------------+
-void TestImpactAnalysis() {
- string testName = "Impact Analysis";
- g_totalTests++;
-
- try {
- // Test impact calculation
- double impact = g_fundamentalAnalysis.CalculateOverallImpact("EURUSD");
-
- if(impact >= 0.0 && impact <= 1.0) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - Impact: " + DoubleToString(impact, 3));
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Invalid impact value: " + DoubleToString(impact, 3));
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Currency Strength Analysis |
-//+------------------------------------------------------------------+
-void TestCurrencyStrengthAnalysis() {
- string testName = "Currency Strength Analysis";
- g_totalTests++;
-
- try {
- // Test currency strength calculation
- double usdStrength = g_fundamentalAnalysis.GetCurrencyStrength("USD");
- double eurStrength = g_fundamentalAnalysis.GetCurrencyStrength("EUR");
-
- if(usdStrength >= -1.0 && usdStrength <= 1.0 &&
- eurStrength >= -1.0 && eurStrength <= 1.0) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - USD: " + DoubleToString(usdStrength, 3) +
- ", EUR: " + DoubleToString(eurStrength, 3));
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Invalid strength values");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Trading Avoidance Logic |
-//+------------------------------------------------------------------+
-void TestTradingAvoidanceLogic() {
- string testName = "Trading Avoidance Logic";
- g_totalTests++;
-
- try {
- // Test should avoid trading logic
- bool shouldAvoid = g_fundamentalAnalysis.ShouldAvoidTrading();
-
- // The result should be boolean
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - Should avoid: " + (shouldAvoid ? "Yes" : "No"));
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Run News Filter Tests |
-//+------------------------------------------------------------------+
-void RunNewsFilterTests() {
- Print("\n--- TESTING NEWS FILTER ---");
-
- // Test 1: Filter Rule Management
- TestFilterRuleManagement();
-
- // Test 2: Trade Evaluation
- TestTradeEvaluation();
-
- // Test 3: Performance Monitoring
- TestPerformanceMonitoring();
-}
-
-//+------------------------------------------------------------------+
-//| Test Filter Rule Management |
-//+------------------------------------------------------------------+
-void TestFilterRuleManagement() {
- string testName = "Filter Rule Management";
- g_totalTests++;
-
- try {
- // Add test filter rule
- SFilterRule testRule;
- testRule.name = "Test High Volatility Rule";
- testRule.type = RULE_TYPE_VOLATILITY;
- testRule.condition = "volatility > 0.8";
- testRule.action = FILTER_ACTION_BLOCK;
- testRule.priority = 1;
- testRule.isActive = true;
-
- bool added = g_newsFilter.AddRule(testRule);
-
- // Test rule retrieval
- SFilterRule retrievedRules[];
- int count = g_newsFilter.GetActiveRules(retrievedRules);
-
- bool found = false;
- for(int i = 0; i < count; i++) {
- if(retrievedRules[i].name == "Test High Volatility Rule") {
- found = true;
- break;
- }
- }
-
- if(added && found) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Rule not properly managed");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Trade Evaluation |
-//+------------------------------------------------------------------+
-void TestTradeEvaluation() {
- string testName = "Trade Evaluation";
- g_totalTests++;
-
- try {
- // Test trade condition evaluation
- SFilterDecision decision = g_newsFilter.EvaluateTradeConditions("EURUSD");
-
- // Verify decision structure
- if(decision.action == FILTER_ACTION_ALLOW ||
- decision.action == FILTER_ACTION_BLOCK ||
- decision.action == FILTER_ACTION_DELAY) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - Action: " + EnumToString(decision.action));
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Invalid decision action");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Performance Monitoring |
-//+------------------------------------------------------------------+
-void TestPerformanceMonitoring() {
- string testName = "Performance Monitoring";
- g_totalTests++;
-
- try {
- // Update performance metrics
- g_newsFilter.UpdatePerformanceMetrics();
-
- // Test should complete without errors
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED");
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Run Integration Tests |
-//+------------------------------------------------------------------+
-void RunIntegrationTests() {
- Print("\n--- TESTING SYSTEM INTEGRATION ---");
-
- // Test 1: Component Communication
- TestComponentCommunication();
-
- // Test 2: End-to-End News Filtering
- TestEndToEndNewsFiltering();
-
- // Test 3: Performance Under Load
- TestPerformanceUnderLoad();
-}
-
-//+------------------------------------------------------------------+
-//| Test Component Communication |
-//+------------------------------------------------------------------+
-void TestComponentCommunication() {
- string testName = "Component Communication";
- g_totalTests++;
-
- try {
- // Test communication between components
- // Add news event that should trigger fundamental analysis
- SNewsEvent event;
- event.title = "Integration Test Event";
- event.currency = "USD";
- event.impact = NEWS_IMPACT_HIGH;
- event.type = NEWS_TYPE_MONETARY_POLICY;
- event.releaseTime = TimeCurrent();
- event.isActive = true;
-
- g_newsManager.AddNewsEvent(event);
-
- // Check if fundamental analysis responds
- bool shouldAvoid = g_fundamentalAnalysis.ShouldAvoidTrading();
-
- // Check if news filter responds
- SFilterDecision decision = g_newsFilter.EvaluateTradeConditions("EURUSD");
-
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - Components communicating");
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test End-to-End News Filtering |
-//+------------------------------------------------------------------+
-void TestEndToEndNewsFiltering() {
- string testName = "End-to-End News Filtering";
- g_totalTests++;
-
- try {
- // Simulate complete news filtering workflow
-
- // 1. Add high impact news
- SNewsEvent highImpactNews;
- highImpactNews.title = "E2E Test NFP";
- highImpactNews.currency = "USD";
- highImpactNews.impact = NEWS_IMPACT_HIGH;
- highImpactNews.type = NEWS_TYPE_EMPLOYMENT;
- highImpactNews.releaseTime = TimeCurrent();
- highImpactNews.isActive = true;
-
- g_newsManager.AddNewsEvent(highImpactNews);
-
- // 2. Check news manager response
- bool isHighImpact = g_newsManager.IsHighImpactNewsTime();
-
- // 3. Check fundamental analysis response
- bool shouldAvoidFundamental = g_fundamentalAnalysis.ShouldAvoidTrading();
-
- // 4. Check news filter response
- SFilterDecision filterDecision = g_newsFilter.EvaluateTradeConditions("EURUSD");
-
- // 5. Verify end-to-end blocking
- bool systemBlocked = isHighImpact || shouldAvoidFundamental ||
- (filterDecision.action == FILTER_ACTION_BLOCK);
-
- if(systemBlocked) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - System properly blocked trading");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - System did not block trading as expected");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Performance Under Load |
-//+------------------------------------------------------------------+
-void TestPerformanceUnderLoad() {
- string testName = "Performance Under Load";
- g_totalTests++;
-
- try {
- uint startTime = GetTickCount();
-
- // Simulate load by performing multiple operations
- for(int i = 0; i < 100; i++) {
- g_newsManager.IsHighImpactNewsTime();
- g_fundamentalAnalysis.ShouldAvoidTrading();
- g_newsFilter.EvaluateTradeConditions("EURUSD");
- }
-
- uint endTime = GetTickCount();
- uint duration = endTime - startTime;
-
- // Performance should be reasonable (less than 1 second for 100 operations)
- if(duration < 1000) {
- g_passedTests++;
- g_testLogger.Info(testName + ": PASSED - Duration: " + IntegerToString(duration) + "ms");
- } else {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - Performance too slow: " + IntegerToString(duration) + "ms");
- }
-
- } catch(string error) {
- g_failedTests++;
- g_testLogger.Error(testName + ": FAILED - " + error);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Generate Test Report |
-//+------------------------------------------------------------------+
-void GenerateTestReport() {
- Print("\n=== NEWS SYSTEM TEST REPORT ===");
- Print("Total Tests: " + IntegerToString(g_totalTests));
- Print("Passed: " + IntegerToString(g_passedTests));
- Print("Failed: " + IntegerToString(g_failedTests));
-
- double successRate = (g_totalTests > 0) ? (double)g_passedTests / g_totalTests * 100.0 : 0.0;
- Print("Success Rate: " + DoubleToString(successRate, 1) + "%");
-
- if(g_failedTests == 0) {
- Print("STATUS: ALL TESTS PASSED โ");
- } else {
- Print("STATUS: " + IntegerToString(g_failedTests) + " TESTS FAILED โ");
- }
-
- Print("================================");
-}
-
-//+------------------------------------------------------------------+
-//| Cleanup Test Environment |
-//+------------------------------------------------------------------+
-void CleanupTestEnvironment() {
- if(g_newsManager != NULL) { delete g_newsManager; g_newsManager = NULL; }
- if(g_fundamentalAnalysis != NULL) { delete g_fundamentalAnalysis; g_fundamentalAnalysis = NULL; }
- if(g_newsFilter != NULL) { delete g_newsFilter; g_newsFilter = NULL; }
- if(g_testLogger != NULL) { delete g_testLogger; g_testLogger = NULL; }
-}
\ No newline at end of file
diff --git a/src/Tests/OptimizationTest.mq5 b/src/Tests/OptimizationTest.mq5
deleted file mode 100644
index fe8255f..0000000
--- a/src/Tests/OptimizationTest.mq5
+++ /dev/null
@@ -1,960 +0,0 @@
-//+------------------------------------------------------------------+
-//| OptimizationTest.mq5 |
-//| MT5 Sniper EA - Optimization |
-//| |
-//+------------------------------------------------------------------+
-#property copyright "MT5 Sniper EA"
-#property version "1.00"
-#property description "Parameter optimization tests for MT5 Sniper EA"
-#property script_show_inputs
-
-// Include all EA components
-#include "../Include/MarketStructure/OrderBlockDetector.mqh"
-#include "../Include/MarketStructure/BOSDetector.mqh"
-#include "../Include/MarketStructure/LiquiditySweepDetector.mqh"
-#include "../Include/MarketStructure/FVGDetector.mqh"
-#include "../Include/MarketStructure/EntryStrategy.mqh"
-#include "../Include/RiskManagement/RiskManager.mqh"
-#include "../Include/SessionManagement/SessionManager.mqh"
-#include "../Include/AIIntegration/GrokAI.mqh"
-#include "../Include/Visualization/ChartManager.mqh"
-#include "../Include/Utils/Backtester.mqh"
-
-// Input parameters
-input string OptimizationSymbol = "EURUSD"; // Symbol to optimize
-input ENUM_TIMEFRAMES OptimizationTimeframe = PERIOD_H1; // Timeframe to optimize
-input datetime OptimizationStartDate = D'2023.01.01'; // Optimization start date
-input datetime OptimizationEndDate = D'2023.12.31'; // Optimization end date
-input double InitialBalance = 10000.0; // Initial balance for optimization
-input int MaxIterations = 1000; // Maximum optimization iterations
-input bool OptimizeRiskParameters = true; // Optimize risk management parameters
-input bool OptimizeEntryParameters = true; // Optimize entry strategy parameters
-input bool OptimizeSessionParameters = true; // Optimize session parameters
-input bool GenerateOptimizationReport = true; // Generate optimization report
-
-//+------------------------------------------------------------------+
-//| Parameter Set Structure |
-//+------------------------------------------------------------------+
-struct SParameterSet
-{
- // Risk management parameters
- double risk_percent;
- double max_risk_percent;
- double daily_loss_limit;
- double max_drawdown_percent;
-
- // Entry strategy parameters
- double min_confluence_score;
- int lookback_periods;
- double ob_strength_threshold;
- double bos_strength_threshold;
- double fvg_size_threshold;
-
- // Session parameters
- bool trade_asia;
- bool trade_london;
- bool trade_ny;
- int avoid_news_minutes;
- double min_volatility;
- double max_volatility;
-
- // Performance metrics
- double net_profit;
- double profit_factor;
- double win_rate;
- double max_drawdown;
- double sharpe_ratio;
- double recovery_factor;
- int total_trades;
- double fitness_score;
-};
-
-//+------------------------------------------------------------------+
-//| Optimization Result Structure |
-//+------------------------------------------------------------------+
-struct SOptimizationResult
-{
- SParameterSet best_parameters;
- SParameterSet worst_parameters;
- double best_fitness;
- double worst_fitness;
- int total_iterations;
- int successful_iterations;
- datetime optimization_time;
-};
-
-//+------------------------------------------------------------------+
-//| Optimization Test Class |
-//+------------------------------------------------------------------+
-class COptimizationTest
-{
-private:
- // Test components
- COrderBlockDetector* m_ob_detector;
- CBOSDetector* m_bos_detector;
- CLiquiditySweepDetector* m_ls_detector;
- CFVGDetector* m_fvg_detector;
- CEntryStrategy* m_entry_strategy;
- CRiskManager* m_risk_manager;
- CSessionManager* m_session_manager;
- CGrokAI* m_grok_ai;
- CChartManager* m_chart_manager;
- CBacktester* m_backtester;
-
- // Optimization data
- SParameterSet m_parameter_sets[];
- SOptimizationResult m_result;
-
- // Parameter ranges
- struct SParameterRanges
- {
- double risk_percent_min, risk_percent_max, risk_percent_step;
- double confluence_min, confluence_max, confluence_step;
- int lookback_min, lookback_max, lookback_step;
- double ob_strength_min, ob_strength_max, ob_strength_step;
- int news_avoid_min, news_avoid_max, news_avoid_step;
- double volatility_min, volatility_max, volatility_step;
- } m_ranges;
-
-public:
- COptimizationTest();
- ~COptimizationTest();
-
- // Main optimization functions
- bool RunOptimization();
- void GenerateOptimizationReport();
-
- // Optimization methods
- bool BruteForceOptimization();
- bool GeneticAlgorithmOptimization();
- bool GridSearchOptimization();
- bool RandomSearchOptimization();
-
- // Parameter generation
- void GenerateParameterSets();
- void GenerateRandomParameterSet(SParameterSet& params);
- void MutateParameterSet(SParameterSet& params, double mutation_rate);
- SParameterSet CrossoverParameterSets(const SParameterSet& parent1, const SParameterSet& parent2);
-
- // Evaluation functions
- double EvaluateParameterSet(const SParameterSet& params);
- double CalculateFitnessScore(const SBacktestStats& stats);
- bool BacktestParameterSet(const SParameterSet& params, SBacktestStats& stats);
-
- // Utility functions
- void InitializeParameterRanges();
- void ApplyParametersToComponents(const SParameterSet& params);
- void SortParameterSetsByFitness();
- void PrintOptimizationProgress(int current, int total);
- void SaveOptimizationResults();
-};
-
-//+------------------------------------------------------------------+
-//| Constructor |
-//+------------------------------------------------------------------+
-COptimizationTest::COptimizationTest()
-{
- // Initialize components
- m_ob_detector = new COrderBlockDetector();
- m_bos_detector = new CBOSDetector();
- m_ls_detector = new CLiquiditySweepDetector();
- m_fvg_detector = new CFVGDetector();
- m_entry_strategy = new CEntryStrategy();
- m_risk_manager = new CRiskManager();
- m_session_manager = new CSessionManager();
- m_grok_ai = new CGrokAI();
- m_chart_manager = new CChartManager();
- m_backtester = new CBacktester();
-
- InitializeParameterRanges();
-}
-
-//+------------------------------------------------------------------+
-//| Destructor |
-//+------------------------------------------------------------------+
-COptimizationTest::~COptimizationTest()
-{
- delete m_ob_detector;
- delete m_bos_detector;
- delete m_ls_detector;
- delete m_fvg_detector;
- delete m_entry_strategy;
- delete m_risk_manager;
- delete m_session_manager;
- delete m_grok_ai;
- delete m_chart_manager;
- delete m_backtester;
-}
-
-//+------------------------------------------------------------------+
-//| Run Optimization |
-//+------------------------------------------------------------------+
-bool COptimizationTest::RunOptimization()
-{
- Print("=== Starting MT5 Sniper EA Parameter Optimization ===");
- Print("Symbol: ", OptimizationSymbol);
- Print("Timeframe: ", EnumToString(OptimizationTimeframe));
- Print("Period: ", TimeToString(OptimizationStartDate), " - ", TimeToString(OptimizationEndDate));
- Print("Max Iterations: ", MaxIterations);
- Print("");
-
- // Initialize components
- m_ob_detector.Initialize(OptimizationSymbol, OptimizationTimeframe);
- m_bos_detector.Initialize(OptimizationSymbol, OptimizationTimeframe);
- m_ls_detector.Initialize(OptimizationSymbol, OptimizationTimeframe);
- m_fvg_detector.Initialize(OptimizationSymbol, OptimizationTimeframe);
- m_entry_strategy.Initialize(OptimizationSymbol, OptimizationTimeframe);
- m_risk_manager.Initialize();
- m_session_manager.Initialize();
- m_grok_ai.Initialize("test_key", "test_url");
- m_chart_manager.Initialize(ChartID());
- m_backtester.Initialize();
-
- // Configure backtester
- SBacktestConfig config;
- config.start_date = OptimizationStartDate;
- config.end_date = OptimizationEndDate;
- config.initial_balance = InitialBalance;
- config.spread = 1.5;
- config.commission = 7.0;
- config.mode = BACKTEST_MODE_OPTIMIZATION;
-
- m_backtester.Configure(config);
- m_backtester.SetEntryStrategy(m_entry_strategy);
- m_backtester.SetRiskManager(m_risk_manager);
- m_backtester.SetSessionManager(m_session_manager);
-
- datetime start_time = TimeCurrent();
-
- // Run optimization using genetic algorithm (most effective for complex parameter spaces)
- bool success = GeneticAlgorithmOptimization();
-
- m_result.optimization_time = TimeCurrent() - start_time;
-
- if(success && GenerateOptimizationReport)
- GenerateOptimizationReport();
-
- return success;
-}
-
-//+------------------------------------------------------------------+
-//| Genetic Algorithm Optimization |
-//+------------------------------------------------------------------+
-bool COptimizationTest::GeneticAlgorithmOptimization()
-{
- Print("Running Genetic Algorithm Optimization...");
-
- const int population_size = 50;
- const int generations = MaxIterations / population_size;
- const double mutation_rate = 0.1;
- const double crossover_rate = 0.8;
- const int elite_count = 5;
-
- // Initialize population
- ArrayResize(m_parameter_sets, population_size);
-
- Print("Generating initial population...");
- for(int i = 0; i < population_size; i++)
- {
- GenerateRandomParameterSet(m_parameter_sets[i]);
- m_parameter_sets[i].fitness_score = EvaluateParameterSet(m_parameter_sets[i]);
-
- if(i % 10 == 0)
- PrintOptimizationProgress(i + 1, population_size);
- }
-
- // Sort by fitness
- SortParameterSetsByFitness();
-
- Print("Initial population generated. Best fitness: ", DoubleToString(m_parameter_sets[0].fitness_score, 2));
-
- // Evolution loop
- for(int gen = 0; gen < generations; gen++)
- {
- Print("Generation ", gen + 1, "/", generations);
-
- SParameterSet new_population[];
- ArrayResize(new_population, population_size);
-
- // Keep elite individuals
- for(int i = 0; i < elite_count; i++)
- {
- new_population[i] = m_parameter_sets[i];
- }
-
- // Generate offspring
- for(int i = elite_count; i < population_size; i++)
- {
- if(MathRand() / 32767.0 < crossover_rate)
- {
- // Crossover
- int parent1_idx = (int)(MathRand() / 32767.0 * elite_count * 2);
- int parent2_idx = (int)(MathRand() / 32767.0 * elite_count * 2);
-
- new_population[i] = CrossoverParameterSets(m_parameter_sets[parent1_idx],
- m_parameter_sets[parent2_idx]);
- }
- else
- {
- // Copy parent
- int parent_idx = (int)(MathRand() / 32767.0 * elite_count * 2);
- new_population[i] = m_parameter_sets[parent_idx];
- }
-
- // Mutation
- if(MathRand() / 32767.0 < mutation_rate)
- {
- MutateParameterSet(new_population[i], mutation_rate);
- }
-
- // Evaluate fitness
- new_population[i].fitness_score = EvaluateParameterSet(new_population[i]);
- }
-
- // Replace population
- ArrayCopy(m_parameter_sets, new_population);
- SortParameterSetsByFitness();
-
- Print("Best fitness: ", DoubleToString(m_parameter_sets[0].fitness_score, 2));
-
- // Early stopping if no improvement
- if(gen > 10)
- {
- bool improved = false;
- for(int i = 0; i < 5; i++)
- {
- if(m_parameter_sets[i].fitness_score > m_result.best_fitness)
- {
- improved = true;
- break;
- }
- }
-
- if(!improved)
- {
- Print("No improvement detected. Stopping early.");
- break;
- }
- }
-
- // Update best result
- if(m_parameter_sets[0].fitness_score > m_result.best_fitness)
- {
- m_result.best_parameters = m_parameter_sets[0];
- m_result.best_fitness = m_parameter_sets[0].fitness_score;
- }
-
- m_result.total_iterations = (gen + 1) * population_size;
- }
-
- // Set final results
- m_result.best_parameters = m_parameter_sets[0];
- m_result.worst_parameters = m_parameter_sets[population_size - 1];
- m_result.best_fitness = m_parameter_sets[0].fitness_score;
- m_result.worst_fitness = m_parameter_sets[population_size - 1].fitness_score;
- m_result.successful_iterations = m_result.total_iterations;
-
- Print("Genetic Algorithm Optimization completed.");
- Print("Best fitness achieved: ", DoubleToString(m_result.best_fitness, 2));
-
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Grid Search Optimization |
-//+------------------------------------------------------------------+
-bool COptimizationTest::GridSearchOptimization()
-{
- Print("Running Grid Search Optimization...");
-
- // Calculate grid dimensions
- int risk_steps = (int)((m_ranges.risk_percent_max - m_ranges.risk_percent_min) / m_ranges.risk_percent_step) + 1;
- int confluence_steps = (int)((m_ranges.confluence_max - m_ranges.confluence_min) / m_ranges.confluence_step) + 1;
- int lookback_steps = (int)((m_ranges.lookback_max - m_ranges.lookback_min) / m_ranges.lookback_step) + 1;
-
- int total_combinations = risk_steps * confluence_steps * lookback_steps;
-
- if(total_combinations > MaxIterations)
- {
- Print("Too many combinations (", total_combinations, "). Reducing grid resolution.");
- // Reduce resolution by increasing step sizes
- m_ranges.risk_percent_step *= 2;
- m_ranges.confluence_step *= 2;
- m_ranges.lookback_step *= 2;
-
- risk_steps = (int)((m_ranges.risk_percent_max - m_ranges.risk_percent_min) / m_ranges.risk_percent_step) + 1;
- confluence_steps = (int)((m_ranges.confluence_max - m_ranges.confluence_min) / m_ranges.confluence_step) + 1;
- lookback_steps = (int)((m_ranges.lookback_max - m_ranges.lookback_min) / m_ranges.lookback_step) + 1;
- total_combinations = risk_steps * confluence_steps * lookback_steps;
- }
-
- Print("Grid dimensions: ", risk_steps, " x ", confluence_steps, " x ", lookback_steps);
- Print("Total combinations: ", total_combinations);
-
- m_result.best_fitness = -999999;
- m_result.worst_fitness = 999999;
-
- int iteration = 0;
-
- // Grid search loop
- for(int r = 0; r < risk_steps; r++)
- {
- double risk_percent = m_ranges.risk_percent_min + (r * m_ranges.risk_percent_step);
-
- for(int c = 0; c < confluence_steps; c++)
- {
- double confluence = m_ranges.confluence_min + (c * m_ranges.confluence_step);
-
- for(int l = 0; l < lookback_steps; l++)
- {
- int lookback = m_ranges.lookback_min + (l * m_ranges.lookback_step);
-
- iteration++;
-
- // Create parameter set
- SParameterSet params;
- GenerateRandomParameterSet(params); // Base parameters
-
- // Override with grid values
- params.risk_percent = risk_percent;
- params.min_confluence_score = confluence;
- params.lookback_periods = lookback;
-
- // Evaluate
- double fitness = EvaluateParameterSet(params);
- params.fitness_score = fitness;
-
- // Update best/worst
- if(fitness > m_result.best_fitness)
- {
- m_result.best_parameters = params;
- m_result.best_fitness = fitness;
- }
-
- if(fitness < m_result.worst_fitness)
- {
- m_result.worst_parameters = params;
- m_result.worst_fitness = fitness;
- }
-
- if(iteration % 50 == 0)
- PrintOptimizationProgress(iteration, total_combinations);
- }
- }
- }
-
- m_result.total_iterations = iteration;
- m_result.successful_iterations = iteration;
-
- Print("Grid Search Optimization completed.");
- Print("Best fitness achieved: ", DoubleToString(m_result.best_fitness, 2));
-
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Random Search Optimization |
-//+------------------------------------------------------------------+
-bool COptimizationTest::RandomSearchOptimization()
-{
- Print("Running Random Search Optimization...");
-
- m_result.best_fitness = -999999;
- m_result.worst_fitness = 999999;
-
- for(int i = 0; i < MaxIterations; i++)
- {
- SParameterSet params;
- GenerateRandomParameterSet(params);
-
- double fitness = EvaluateParameterSet(params);
- params.fitness_score = fitness;
-
- // Update best/worst
- if(fitness > m_result.best_fitness)
- {
- m_result.best_parameters = params;
- m_result.best_fitness = fitness;
- }
-
- if(fitness < m_result.worst_fitness)
- {
- m_result.worst_parameters = params;
- m_result.worst_fitness = fitness;
- }
-
- if(i % 100 == 0)
- PrintOptimizationProgress(i + 1, MaxIterations);
- }
-
- m_result.total_iterations = MaxIterations;
- m_result.successful_iterations = MaxIterations;
-
- Print("Random Search Optimization completed.");
- Print("Best fitness achieved: ", DoubleToString(m_result.best_fitness, 2));
-
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Generate Random Parameter Set |
-//+------------------------------------------------------------------+
-void COptimizationTest::GenerateRandomParameterSet(SParameterSet& params)
-{
- // Risk management parameters
- params.risk_percent = m_ranges.risk_percent_min +
- (MathRand() / 32767.0) * (m_ranges.risk_percent_max - m_ranges.risk_percent_min);
- params.max_risk_percent = params.risk_percent * (1.5 + MathRand() / 32767.0);
- params.daily_loss_limit = params.risk_percent * (1.0 + MathRand() / 32767.0);
- params.max_drawdown_percent = 5.0 + (MathRand() / 32767.0) * 15.0;
-
- // Entry strategy parameters
- params.min_confluence_score = m_ranges.confluence_min +
- (MathRand() / 32767.0) * (m_ranges.confluence_max - m_ranges.confluence_min);
- params.lookback_periods = m_ranges.lookback_min +
- (int)((MathRand() / 32767.0) * (m_ranges.lookback_max - m_ranges.lookback_min));
- params.ob_strength_threshold = m_ranges.ob_strength_min +
- (MathRand() / 32767.0) * (m_ranges.ob_strength_max - m_ranges.ob_strength_min);
- params.bos_strength_threshold = 0.3 + (MathRand() / 32767.0) * 0.5;
- params.fvg_size_threshold = 5.0 + (MathRand() / 32767.0) * 15.0;
-
- // Session parameters
- params.trade_asia = (MathRand() % 2) == 1;
- params.trade_london = true; // Always trade London (most liquid)
- params.trade_ny = (MathRand() % 2) == 1;
- params.avoid_news_minutes = m_ranges.news_avoid_min +
- (int)((MathRand() / 32767.0) * (m_ranges.news_avoid_max - m_ranges.news_avoid_min));
- params.min_volatility = m_ranges.volatility_min +
- (MathRand() / 32767.0) * (m_ranges.volatility_max - m_ranges.volatility_min);
- params.max_volatility = params.min_volatility + (MathRand() / 32767.0) * 0.5;
-}
-
-//+------------------------------------------------------------------+
-//| Mutate Parameter Set |
-//+------------------------------------------------------------------+
-void COptimizationTest::MutateParameterSet(SParameterSet& params, double mutation_rate)
-{
- // Mutate each parameter with given probability
- if(MathRand() / 32767.0 < mutation_rate)
- {
- params.risk_percent += (MathRand() / 32767.0 - 0.5) * 0.5;
- params.risk_percent = MathMax(m_ranges.risk_percent_min,
- MathMin(m_ranges.risk_percent_max, params.risk_percent));
- }
-
- if(MathRand() / 32767.0 < mutation_rate)
- {
- params.min_confluence_score += (MathRand() / 32767.0 - 0.5) * 0.2;
- params.min_confluence_score = MathMax(m_ranges.confluence_min,
- MathMin(m_ranges.confluence_max, params.min_confluence_score));
- }
-
- if(MathRand() / 32767.0 < mutation_rate)
- {
- params.lookback_periods += (int)((MathRand() / 32767.0 - 0.5) * 20);
- params.lookback_periods = (int)MathMax(m_ranges.lookback_min,
- MathMin(m_ranges.lookback_max, params.lookback_periods));
- }
-
- if(MathRand() / 32767.0 < mutation_rate)
- {
- params.ob_strength_threshold += (MathRand() / 32767.0 - 0.5) * 0.2;
- params.ob_strength_threshold = MathMax(m_ranges.ob_strength_min,
- MathMin(m_ranges.ob_strength_max, params.ob_strength_threshold));
- }
-
- if(MathRand() / 32767.0 < mutation_rate)
- {
- params.avoid_news_minutes += (int)((MathRand() / 32767.0 - 0.5) * 30);
- params.avoid_news_minutes = (int)MathMax(m_ranges.news_avoid_min,
- MathMin(m_ranges.news_avoid_max, params.avoid_news_minutes));
- }
-}
-
-//+------------------------------------------------------------------+
-//| Crossover Parameter Sets |
-//+------------------------------------------------------------------+
-SParameterSet COptimizationTest::CrossoverParameterSets(const SParameterSet& parent1, const SParameterSet& parent2)
-{
- SParameterSet offspring;
-
- // Uniform crossover - randomly select from each parent
- offspring.risk_percent = (MathRand() % 2) ? parent1.risk_percent : parent2.risk_percent;
- offspring.max_risk_percent = (MathRand() % 2) ? parent1.max_risk_percent : parent2.max_risk_percent;
- offspring.daily_loss_limit = (MathRand() % 2) ? parent1.daily_loss_limit : parent2.daily_loss_limit;
- offspring.max_drawdown_percent = (MathRand() % 2) ? parent1.max_drawdown_percent : parent2.max_drawdown_percent;
-
- offspring.min_confluence_score = (MathRand() % 2) ? parent1.min_confluence_score : parent2.min_confluence_score;
- offspring.lookback_periods = (MathRand() % 2) ? parent1.lookback_periods : parent2.lookback_periods;
- offspring.ob_strength_threshold = (MathRand() % 2) ? parent1.ob_strength_threshold : parent2.ob_strength_threshold;
- offspring.bos_strength_threshold = (MathRand() % 2) ? parent1.bos_strength_threshold : parent2.bos_strength_threshold;
- offspring.fvg_size_threshold = (MathRand() % 2) ? parent1.fvg_size_threshold : parent2.fvg_size_threshold;
-
- offspring.trade_asia = (MathRand() % 2) ? parent1.trade_asia : parent2.trade_asia;
- offspring.trade_london = (MathRand() % 2) ? parent1.trade_london : parent2.trade_london;
- offspring.trade_ny = (MathRand() % 2) ? parent1.trade_ny : parent2.trade_ny;
- offspring.avoid_news_minutes = (MathRand() % 2) ? parent1.avoid_news_minutes : parent2.avoid_news_minutes;
- offspring.min_volatility = (MathRand() % 2) ? parent1.min_volatility : parent2.min_volatility;
- offspring.max_volatility = (MathRand() % 2) ? parent1.max_volatility : parent2.max_volatility;
-
- return offspring;
-}
-
-//+------------------------------------------------------------------+
-//| Evaluate Parameter Set |
-//+------------------------------------------------------------------+
-double COptimizationTest::EvaluateParameterSet(const SParameterSet& params)
-{
- // Apply parameters to components
- ApplyParametersToComponents(params);
-
- // Run backtest
- SBacktestStats stats;
- if(!BacktestParameterSet(params, stats))
- return -999999; // Invalid parameter set
-
- // Calculate fitness score
- return CalculateFitnessScore(stats);
-}
-
-//+------------------------------------------------------------------+
-//| Calculate Fitness Score |
-//+------------------------------------------------------------------+
-double COptimizationTest::CalculateFitnessScore(const SBacktestStats& stats)
-{
- // Multi-objective fitness function
- double fitness = 0.0;
-
- // Profit factor (30% weight)
- if(stats.profit_factor > 1.0)
- fitness += (stats.profit_factor - 1.0) * 30.0;
- else
- fitness -= (1.0 - stats.profit_factor) * 50.0; // Penalty for losing systems
-
- // Win rate (20% weight)
- fitness += stats.win_rate * 20.0;
-
- // Net profit normalized by initial balance (25% weight)
- fitness += (stats.net_profit / InitialBalance) * 25.0;
-
- // Recovery factor (15% weight) - Net profit / Max drawdown
- if(stats.max_drawdown > 0)
- fitness += (stats.net_profit / stats.max_drawdown) * 15.0;
-
- // Sharpe ratio (10% weight)
- if(stats.sharpe_ratio > 0)
- fitness += stats.sharpe_ratio * 10.0;
-
- // Penalty for excessive drawdown
- if(stats.max_drawdown > InitialBalance * 0.3) // More than 30% drawdown
- fitness -= 50.0;
-
- // Penalty for too few trades
- if(stats.total_trades < 10)
- fitness -= 20.0;
-
- // Penalty for too many trades (overtrading)
- if(stats.total_trades > 1000)
- fitness -= 10.0;
-
- return fitness;
-}
-
-//+------------------------------------------------------------------+
-//| Backtest Parameter Set |
-//+------------------------------------------------------------------+
-bool COptimizationTest::BacktestParameterSet(const SParameterSet& params, SBacktestStats& stats)
-{
- try
- {
- // Reset backtester
- m_backtester.Reset();
-
- // Run backtest
- bool success = m_backtester.RunBacktest();
-
- if(!success)
- return false;
-
- // Get statistics
- m_backtester.CalculateStatistics(stats);
-
- return true;
- }
- catch(...)
- {
- return false;
- }
-}
-
-//+------------------------------------------------------------------+
-//| Apply Parameters to Components |
-//+------------------------------------------------------------------+
-void COptimizationTest::ApplyParametersToComponents(const SParameterSet& params)
-{
- // Apply risk management parameters
- SRiskProfile risk_profile;
- risk_profile.risk_percent = params.risk_percent;
- risk_profile.max_risk_percent = params.max_risk_percent;
- risk_profile.daily_loss_limit = params.daily_loss_limit;
- risk_profile.max_drawdown_percent = params.max_drawdown_percent;
- risk_profile.risk_model = RISK_MODEL_PERCENTAGE;
-
- m_risk_manager.SetRiskProfile(risk_profile);
-
- // Apply entry strategy parameters
- SEntryRequirements requirements;
- requirements.min_confluence_score = params.min_confluence_score;
- requirements.require_order_block = true;
- requirements.require_bos = true;
- requirements.require_liquidity_sweep = false;
- requirements.require_fvg = false;
-
- m_entry_strategy.SetRequirements(requirements);
-
- // Apply detector configurations
- SOrderBlockConfig ob_config;
- ob_config.lookback_periods = params.lookback_periods;
- ob_config.strength_threshold = params.ob_strength_threshold;
- ob_config.min_body_size = 10.0;
- ob_config.max_age_bars = 100;
-
- m_ob_detector.Configure(ob_config);
-
- SBOSConfig bos_config;
- bos_config.lookback_periods = params.lookback_periods;
- bos_config.strength_threshold = params.bos_strength_threshold;
- bos_config.min_break_distance = 5.0;
-
- m_bos_detector.Configure(bos_config);
-
- SFVGConfig fvg_config;
- fvg_config.min_gap_size = params.fvg_size_threshold;
- fvg_config.lookback_periods = params.lookback_periods;
- fvg_config.require_volume_confirmation = false;
-
- m_fvg_detector.Configure(fvg_config);
-
- // Apply session parameters
- SSessionConfig session_config;
- session_config.trade_asia = params.trade_asia;
- session_config.trade_london = params.trade_london;
- session_config.trade_ny = params.trade_ny;
- session_config.avoid_news_minutes = params.avoid_news_minutes;
- session_config.min_volatility = params.min_volatility;
- session_config.max_volatility = params.max_volatility;
-
- m_session_manager.Configure(session_config);
-}
-
-//+------------------------------------------------------------------+
-//| Initialize Parameter Ranges |
-//+------------------------------------------------------------------+
-void COptimizationTest::InitializeParameterRanges()
-{
- // Risk management ranges
- m_ranges.risk_percent_min = 0.5;
- m_ranges.risk_percent_max = 5.0;
- m_ranges.risk_percent_step = 0.5;
-
- // Entry strategy ranges
- m_ranges.confluence_min = 0.3;
- m_ranges.confluence_max = 0.9;
- m_ranges.confluence_step = 0.1;
-
- m_ranges.lookback_min = 20;
- m_ranges.lookback_max = 200;
- m_ranges.lookback_step = 20;
-
- m_ranges.ob_strength_min = 0.3;
- m_ranges.ob_strength_max = 0.8;
- m_ranges.ob_strength_step = 0.1;
-
- // Session ranges
- m_ranges.news_avoid_min = 0;
- m_ranges.news_avoid_max = 60;
- m_ranges.news_avoid_step = 15;
-
- m_ranges.volatility_min = 0.001;
- m_ranges.volatility_max = 0.01;
- m_ranges.volatility_step = 0.001;
-}
-
-//+------------------------------------------------------------------+
-//| Sort Parameter Sets by Fitness |
-//+------------------------------------------------------------------+
-void COptimizationTest::SortParameterSetsByFitness()
-{
- int size = ArraySize(m_parameter_sets);
-
- // Simple bubble sort (sufficient for small populations)
- for(int i = 0; i < size - 1; i++)
- {
- for(int j = 0; j < size - i - 1; j++)
- {
- if(m_parameter_sets[j].fitness_score < m_parameter_sets[j + 1].fitness_score)
- {
- SParameterSet temp = m_parameter_sets[j];
- m_parameter_sets[j] = m_parameter_sets[j + 1];
- m_parameter_sets[j + 1] = temp;
- }
- }
- }
-}
-
-//+------------------------------------------------------------------+
-//| Print Optimization Progress |
-//+------------------------------------------------------------------+
-void COptimizationTest::PrintOptimizationProgress(int current, int total)
-{
- double progress = (double)current / total * 100.0;
- Print("Progress: ", current, "/", total, " (", DoubleToString(progress, 1), "%)");
-}
-
-//+------------------------------------------------------------------+
-//| Generate Optimization Report |
-//+------------------------------------------------------------------+
-void COptimizationTest::GenerateOptimizationReport()
-{
- Print("");
- Print("=== MT5 Sniper EA Optimization Report ===");
- Print("");
-
- Print("Optimization Summary:");
- Print("--------------------");
- Print("Symbol: ", OptimizationSymbol);
- Print("Timeframe: ", EnumToString(OptimizationTimeframe));
- Print("Period: ", TimeToString(OptimizationStartDate), " - ", TimeToString(OptimizationEndDate));
- Print("Total Iterations: ", m_result.total_iterations);
- Print("Successful Iterations: ", m_result.successful_iterations);
- Print("Optimization Time: ", m_result.optimization_time, " seconds");
- Print("");
-
- Print("Best Parameter Set:");
- Print("------------------");
- SParameterSet& best = m_result.best_parameters;
- Print("Fitness Score: ", DoubleToString(best.fitness_score, 2));
- Print("Risk Percent: ", DoubleToString(best.risk_percent, 2), "%");
- Print("Max Risk Percent: ", DoubleToString(best.max_risk_percent, 2), "%");
- Print("Daily Loss Limit: ", DoubleToString(best.daily_loss_limit, 2), "%");
- Print("Max Drawdown: ", DoubleToString(best.max_drawdown_percent, 2), "%");
- Print("Min Confluence Score: ", DoubleToString(best.min_confluence_score, 2));
- Print("Lookback Periods: ", best.lookback_periods);
- Print("OB Strength Threshold: ", DoubleToString(best.ob_strength_threshold, 2));
- Print("BOS Strength Threshold: ", DoubleToString(best.bos_strength_threshold, 2));
- Print("FVG Size Threshold: ", DoubleToString(best.fvg_size_threshold, 1), " pips");
- Print("Trade Asia: ", best.trade_asia ? "Yes" : "No");
- Print("Trade London: ", best.trade_london ? "Yes" : "No");
- Print("Trade NY: ", best.trade_ny ? "Yes" : "No");
- Print("Avoid News Minutes: ", best.avoid_news_minutes);
- Print("Min Volatility: ", DoubleToString(best.min_volatility, 4));
- Print("Max Volatility: ", DoubleToString(best.max_volatility, 4));
- Print("");
-
- Print("Performance Metrics:");
- Print("-------------------");
- Print("Net Profit: $", DoubleToString(best.net_profit, 2));
- Print("Profit Factor: ", DoubleToString(best.profit_factor, 2));
- Print("Win Rate: ", DoubleToString(best.win_rate * 100, 2), "%");
- Print("Max Drawdown: $", DoubleToString(best.max_drawdown, 2));
- Print("Sharpe Ratio: ", DoubleToString(best.sharpe_ratio, 2));
- Print("Recovery Factor: ", DoubleToString(best.recovery_factor, 2));
- Print("Total Trades: ", best.total_trades);
- Print("");
-
- // Save detailed report to file
- SaveOptimizationResults();
-}
-
-//+------------------------------------------------------------------+
-//| Save Optimization Results |
-//+------------------------------------------------------------------+
-void COptimizationTest::SaveOptimizationResults()
-{
- string filename = "SniperEA_OptimizationReport_" + OptimizationSymbol + "_" +
- EnumToString(OptimizationTimeframe) + "_" +
- TimeToString(TimeCurrent(), TIME_DATE) + ".csv";
-
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_CSV);
-
- if(file_handle != INVALID_HANDLE)
- {
- // Write header
- FileWrite(file_handle, "Parameter", "Value", "Description");
- FileWrite(file_handle, "Symbol", OptimizationSymbol, "Trading symbol");
- FileWrite(file_handle, "Timeframe", EnumToString(OptimizationTimeframe), "Chart timeframe");
- FileWrite(file_handle, "Start Date", TimeToString(OptimizationStartDate), "Optimization start");
- FileWrite(file_handle, "End Date", TimeToString(OptimizationEndDate), "Optimization end");
- FileWrite(file_handle, "Total Iterations", m_result.total_iterations, "Total parameter sets tested");
- FileWrite(file_handle, "Optimization Time", m_result.optimization_time, "Time taken (seconds)");
- FileWrite(file_handle, "", "", "");
-
- // Write best parameters
- SParameterSet& best = m_result.best_parameters;
- FileWrite(file_handle, "BEST PARAMETERS", "", "");
- FileWrite(file_handle, "Fitness Score", best.fitness_score, "Overall fitness score");
- FileWrite(file_handle, "Risk Percent", best.risk_percent, "Risk per trade (%)");
- FileWrite(file_handle, "Max Risk Percent", best.max_risk_percent, "Maximum risk (%)");
- FileWrite(file_handle, "Daily Loss Limit", best.daily_loss_limit, "Daily loss limit (%)");
- FileWrite(file_handle, "Max Drawdown Percent", best.max_drawdown_percent, "Maximum drawdown (%)");
- FileWrite(file_handle, "Min Confluence Score", best.min_confluence_score, "Minimum confluence for entry");
- FileWrite(file_handle, "Lookback Periods", best.lookback_periods, "Analysis lookback periods");
- FileWrite(file_handle, "OB Strength Threshold", best.ob_strength_threshold, "Order block strength threshold");
- FileWrite(file_handle, "BOS Strength Threshold", best.bos_strength_threshold, "BOS strength threshold");
- FileWrite(file_handle, "FVG Size Threshold", best.fvg_size_threshold, "FVG minimum size (pips)");
- FileWrite(file_handle, "Trade Asia", best.trade_asia, "Trade during Asia session");
- FileWrite(file_handle, "Trade London", best.trade_london, "Trade during London session");
- FileWrite(file_handle, "Trade NY", best.trade_ny, "Trade during NY session");
- FileWrite(file_handle, "Avoid News Minutes", best.avoid_news_minutes, "Minutes to avoid around news");
- FileWrite(file_handle, "Min Volatility", best.min_volatility, "Minimum volatility threshold");
- FileWrite(file_handle, "Max Volatility", best.max_volatility, "Maximum volatility threshold");
- FileWrite(file_handle, "", "", "");
-
- // Write performance metrics
- FileWrite(file_handle, "PERFORMANCE METRICS", "", "");
- FileWrite(file_handle, "Net Profit", best.net_profit, "Total profit/loss");
- FileWrite(file_handle, "Profit Factor", best.profit_factor, "Gross profit / Gross loss");
- FileWrite(file_handle, "Win Rate", best.win_rate, "Percentage of winning trades");
- FileWrite(file_handle, "Max Drawdown", best.max_drawdown, "Maximum drawdown amount");
- FileWrite(file_handle, "Sharpe Ratio", best.sharpe_ratio, "Risk-adjusted return");
- FileWrite(file_handle, "Recovery Factor", best.recovery_factor, "Net profit / Max drawdown");
- FileWrite(file_handle, "Total Trades", best.total_trades, "Total number of trades");
-
- FileClose(file_handle);
- Print("Optimization report saved to: ", filename);
- }
- else
- {
- Print("Failed to save optimization report");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Script start function |
-//+------------------------------------------------------------------+
-void OnStart()
-{
- Print("Starting MT5 Sniper EA Parameter Optimization...");
- Print("This will find the optimal parameter combinations for maximum performance.");
- Print("");
-
- COptimizationTest* optimizer = new COptimizationTest();
-
- bool success = optimizer.RunOptimization();
-
- if(success)
- {
- Print("");
- Print("๐ฏ Parameter optimization completed successfully!");
- Print("Check the optimization report for the best parameter settings.");
- }
- else
- {
- Print("");
- Print("โ ๏ธ Parameter optimization failed. Please check the logs for errors.");
- }
-
- delete optimizer;
-
- Print("Optimization testing completed.");
-}
\ No newline at end of file
diff --git a/src/Tests/PerformanceTest.mq5 b/src/Tests/PerformanceTest.mq5
deleted file mode 100644
index 84c35d3..0000000
--- a/src/Tests/PerformanceTest.mq5
+++ /dev/null
@@ -1,904 +0,0 @@
-//+------------------------------------------------------------------+
-//| PerformanceTest.mq5 |
-//| MT5 Sniper EA - Performance |
-//| |
-//+------------------------------------------------------------------+
-#property copyright "MT5 Sniper EA"
-#property version "1.00"
-#property description "Performance benchmarking for MT5 Sniper EA"
-#property script_show_inputs
-
-// Include all EA components
-#include "../Include/MarketStructure/OrderBlockDetector.mqh"
-#include "../Include/MarketStructure/BOSDetector.mqh"
-#include "../Include/MarketStructure/LiquiditySweepDetector.mqh"
-#include "../Include/MarketStructure/FVGDetector.mqh"
-#include "../Include/MarketStructure/EntryStrategy.mqh"
-#include "../Include/RiskManagement/RiskManager.mqh"
-#include "../Include/SessionManagement/SessionManager.mqh"
-#include "../Include/AIIntegration/GrokAI.mqh"
-#include "../Include/Visualization/ChartManager.mqh"
-#include "../Include/Utils/Backtester.mqh"
-
-// Input parameters
-input int TestIterations = 1000; // Number of test iterations
-input bool TestMemoryUsage = true; // Test memory usage
-input bool TestConcurrency = true; // Test concurrent operations
-input bool GenerateReport = true; // Generate performance report
-
-//+------------------------------------------------------------------+
-//| Performance Metrics Structure |
-//+------------------------------------------------------------------+
-struct SPerformanceMetrics
-{
- string component_name;
- double avg_execution_time;
- double min_execution_time;
- double max_execution_time;
- double total_execution_time;
- int iterations;
- double memory_usage_mb;
- bool passed_benchmark;
-};
-
-//+------------------------------------------------------------------+
-//| Performance Test Class |
-//+------------------------------------------------------------------+
-class CPerformanceTest
-{
-private:
- // Test components
- COrderBlockDetector* m_ob_detector;
- CBOSDetector* m_bos_detector;
- CLiquiditySweepDetector* m_ls_detector;
- CFVGDetector* m_fvg_detector;
- CEntryStrategy* m_entry_strategy;
- CRiskManager* m_risk_manager;
- CSessionManager* m_session_manager;
- CGrokAI* m_grok_ai;
- CChartManager* m_chart_manager;
- CBacktester* m_backtester;
-
- // Performance metrics
- SPerformanceMetrics m_metrics[];
-
- // Benchmark thresholds (microseconds)
- double m_ob_threshold;
- double m_bos_threshold;
- double m_ls_threshold;
- double m_fvg_threshold;
- double m_entry_threshold;
- double m_risk_threshold;
- double m_session_threshold;
- double m_ai_threshold;
- double m_chart_threshold;
- double m_backtest_threshold;
-
-public:
- CPerformanceTest();
- ~CPerformanceTest();
-
- // Main test functions
- bool RunPerformanceTests();
- void GeneratePerformanceReport();
-
- // Component performance tests
- void TestOrderBlockPerformance();
- void TestBOSPerformance();
- void TestLiquiditySweepPerformance();
- void TestFVGPerformance();
- void TestEntryStrategyPerformance();
- void TestRiskManagerPerformance();
- void TestSessionManagerPerformance();
- void TestGrokAIPerformance();
- void TestChartManagerPerformance();
- void TestBacktesterPerformance();
-
- // Specialized tests
- void TestMemoryUsage();
- void TestConcurrentOperations();
- void TestScalabilityLimits();
- void TestResourceCleanup();
-
- // Utility functions
- void AddMetrics(string name, double avg_time, double min_time, double max_time,
- double total_time, int iterations, double memory_mb, bool passed);
- double GetMemoryUsage();
- void SetBenchmarkThresholds();
- void PrintPerformanceResults();
-};
-
-//+------------------------------------------------------------------+
-//| Constructor |
-//+------------------------------------------------------------------+
-CPerformanceTest::CPerformanceTest()
-{
- // Initialize components
- m_ob_detector = new COrderBlockDetector();
- m_bos_detector = new CBOSDetector();
- m_ls_detector = new CLiquiditySweepDetector();
- m_fvg_detector = new CFVGDetector();
- m_entry_strategy = new CEntryStrategy();
- m_risk_manager = new CRiskManager();
- m_session_manager = new CSessionManager();
- m_grok_ai = new CGrokAI();
- m_chart_manager = new CChartManager();
- m_backtester = new CBacktester();
-
- SetBenchmarkThresholds();
-}
-
-//+------------------------------------------------------------------+
-//| Destructor |
-//+------------------------------------------------------------------+
-CPerformanceTest::~CPerformanceTest()
-{
- delete m_ob_detector;
- delete m_bos_detector;
- delete m_ls_detector;
- delete m_fvg_detector;
- delete m_entry_strategy;
- delete m_risk_manager;
- delete m_session_manager;
- delete m_grok_ai;
- delete m_chart_manager;
- delete m_backtester;
-}
-
-//+------------------------------------------------------------------+
-//| Set Benchmark Thresholds |
-//+------------------------------------------------------------------+
-void CPerformanceTest::SetBenchmarkThresholds()
-{
- // Performance thresholds in microseconds (acceptable execution times)
- m_ob_threshold = 10000; // 10ms for Order Block detection
- m_bos_threshold = 5000; // 5ms for BOS detection
- m_ls_threshold = 8000; // 8ms for Liquidity Sweep detection
- m_fvg_threshold = 3000; // 3ms for FVG detection
- m_entry_threshold = 15000; // 15ms for Entry Strategy analysis
- m_risk_threshold = 1000; // 1ms for Risk calculations
- m_session_threshold = 500; // 0.5ms for Session checks
- m_ai_threshold = 50000; // 50ms for AI analysis (network dependent)
- m_chart_threshold = 2000; // 2ms for Chart operations
- m_backtest_threshold = 100000; // 100ms for Backtest operations
-}
-
-//+------------------------------------------------------------------+
-//| Run Performance Tests |
-//+------------------------------------------------------------------+
-bool CPerformanceTest::RunPerformanceTests()
-{
- Print("=== Starting MT5 Sniper EA Performance Tests ===");
- Print("Test Iterations: ", TestIterations);
- Print("");
-
- // Initialize components
- m_ob_detector.Initialize("EURUSD", PERIOD_H1);
- m_bos_detector.Initialize("EURUSD", PERIOD_H1);
- m_ls_detector.Initialize("EURUSD", PERIOD_H1);
- m_fvg_detector.Initialize("EURUSD", PERIOD_H1);
- m_entry_strategy.Initialize("EURUSD", PERIOD_H1);
- m_risk_manager.Initialize();
- m_session_manager.Initialize();
- m_grok_ai.Initialize("test_key", "test_url");
- m_chart_manager.Initialize(ChartID());
- m_backtester.Initialize();
-
- // Run component performance tests
- TestOrderBlockPerformance();
- TestBOSPerformance();
- TestLiquiditySweepPerformance();
- TestFVGPerformance();
- TestEntryStrategyPerformance();
- TestRiskManagerPerformance();
- TestSessionManagerPerformance();
- TestGrokAIPerformance();
- TestChartManagerPerformance();
- TestBacktesterPerformance();
-
- // Run specialized tests
- if(TestMemoryUsage)
- TestMemoryUsage();
-
- if(TestConcurrency)
- TestConcurrentOperations();
-
- TestScalabilityLimits();
- TestResourceCleanup();
-
- // Generate report
- if(GenerateReport)
- GeneratePerformanceReport();
-
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Test Order Block Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestOrderBlockPerformance()
-{
- Print("Testing Order Block Detector Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- SOrderBlock blocks[];
- m_ob_detector.DetectOrderBlocks(blocks);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_ob_threshold);
-
- AddMetrics("Order Block Detector", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("Order Block Detector - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test BOS Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestBOSPerformance()
-{
- Print("Testing BOS Detector Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- SBOS signals[];
- m_bos_detector.DetectBOS(signals);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_bos_threshold);
-
- AddMetrics("BOS Detector", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("BOS Detector - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Liquidity Sweep Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestLiquiditySweepPerformance()
-{
- Print("Testing Liquidity Sweep Detector Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- SLiquiditySweep sweeps[];
- m_ls_detector.DetectSweeps(sweeps);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_ls_threshold);
-
- AddMetrics("Liquidity Sweep Detector", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("Liquidity Sweep Detector - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test FVG Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestFVGPerformance()
-{
- Print("Testing FVG Detector Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- SFVG gaps[];
- m_fvg_detector.DetectFVG(gaps);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_fvg_threshold);
-
- AddMetrics("FVG Detector", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("FVG Detector - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Entry Strategy Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestEntryStrategyPerformance()
-{
- Print("Testing Entry Strategy Performance...");
-
- // Configure entry strategy
- m_entry_strategy.ConfigureOrderBlockDetector(m_ob_detector);
- m_entry_strategy.ConfigureBOSDetector(m_bos_detector);
- m_entry_strategy.ConfigureLiquiditySweepDetector(m_ls_detector);
- m_entry_strategy.ConfigureFVGDetector(m_fvg_detector);
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- SEntrySignal signal;
- m_entry_strategy.AnalyzeEntry(signal);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_entry_threshold);
-
- AddMetrics("Entry Strategy", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("Entry Strategy - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Risk Manager Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestRiskManagerPerformance()
-{
- Print("Testing Risk Manager Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- double position_size = m_risk_manager.CalculatePositionSize("EURUSD", 50);
- double stop_loss = m_risk_manager.CalculateStopLoss("EURUSD", ORDER_TYPE_BUY, 1.1000, 50);
- double take_profit = m_risk_manager.CalculateTakeProfit("EURUSD", ORDER_TYPE_BUY, 1.1000, 100);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_risk_threshold);
-
- AddMetrics("Risk Manager", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("Risk Manager - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Session Manager Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestSessionManagerPerformance()
-{
- Print("Testing Session Manager Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- ENUM_TRADING_SESSION session = m_session_manager.GetCurrentSession();
- bool trading_allowed = m_session_manager.IsTradingAllowed();
- ENUM_SESSION_PHASE phase = m_session_manager.GetSessionPhase();
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_session_threshold);
-
- AddMetrics("Session Manager", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("Session Manager - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Grok AI Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestGrokAIPerformance()
-{
- Print("Testing Grok AI Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- // Note: AI tests may fail due to network/API limitations
- int successful_calls = 0;
-
- for(int i = 0; i < MathMin(TestIterations, 10); i++) // Limit AI tests to 10 iterations
- {
- ulong start_time = GetMicrosecondCount();
-
- SAIAnalysis analysis;
- bool success = m_grok_ai.RequestAnalysis("EURUSD", analysis);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(success)
- {
- successful_calls++;
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = successful_calls > 0 ? total_time / successful_calls : 0;
- bool passed = (avg_time <= m_ai_threshold) || (successful_calls == 0); // Pass if no API available
-
- AddMetrics("Grok AI", avg_time, min_time, max_time,
- total_time, successful_calls, memory_after - memory_before, passed);
-
- Print("Grok AI - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Successful Calls: ", successful_calls, ", Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Chart Manager Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestChartManagerPerformance()
-{
- Print("Testing Chart Manager Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- for(int i = 0; i < TestIterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- // Test drawing operations
- SOrderBlock test_block;
- test_block.high = 1.1000 + i * 0.0001;
- test_block.low = 1.0950 + i * 0.0001;
- test_block.start_time = TimeCurrent() - 3600;
- test_block.type = ORDER_BLOCK_BULLISH;
-
- string obj_name = m_chart_manager.DrawOrderBlock(test_block);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
-
- // Clean up object to avoid chart clutter
- if(StringLen(obj_name) > 0)
- ObjectDelete(ChartID(), obj_name);
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / TestIterations;
- bool passed = (avg_time <= m_chart_threshold);
-
- AddMetrics("Chart Manager", avg_time, min_time, max_time,
- total_time, TestIterations, memory_after - memory_before, passed);
-
- Print("Chart Manager - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Backtester Performance |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestBacktesterPerformance()
-{
- Print("Testing Backtester Performance...");
-
- double min_time = DBL_MAX;
- double max_time = 0;
- double total_time = 0;
- double memory_before = GetMemoryUsage();
-
- // Configure backtester
- m_backtester.SetEntryStrategy(m_entry_strategy);
- m_backtester.SetRiskManager(m_risk_manager);
- m_backtester.SetSessionManager(m_session_manager);
-
- int test_iterations = MathMin(TestIterations, 100); // Limit backtest iterations
-
- for(int i = 0; i < test_iterations; i++)
- {
- ulong start_time = GetMicrosecondCount();
-
- SBacktestStats stats;
- m_backtester.CalculateStatistics(stats);
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- if(execution_time < min_time) min_time = execution_time;
- if(execution_time > max_time) max_time = execution_time;
- total_time += execution_time;
- }
-
- double memory_after = GetMemoryUsage();
- double avg_time = total_time / test_iterations;
- bool passed = (avg_time <= m_backtest_threshold);
-
- AddMetrics("Backtester", avg_time, min_time, max_time,
- total_time, test_iterations, memory_after - memory_before, passed);
-
- Print("Backtester - Avg: ", DoubleToString(avg_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Memory Usage |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestMemoryUsage()
-{
- Print("Testing Memory Usage...");
-
- double initial_memory = GetMemoryUsage();
-
- // Create multiple instances to test memory scaling
- COrderBlockDetector* detectors[];
- ArrayResize(detectors, 100);
-
- for(int i = 0; i < 100; i++)
- {
- detectors[i] = new COrderBlockDetector();
- detectors[i].Initialize("EURUSD", PERIOD_H1);
- }
-
- double peak_memory = GetMemoryUsage();
-
- // Clean up
- for(int i = 0; i < 100; i++)
- {
- delete detectors[i];
- }
-
- double final_memory = GetMemoryUsage();
-
- Print("Memory Usage Test:");
- Print("Initial: ", DoubleToString(initial_memory, 2), " MB");
- Print("Peak: ", DoubleToString(peak_memory, 2), " MB");
- Print("Final: ", DoubleToString(final_memory, 2), " MB");
- Print("Memory Leak: ", DoubleToString(final_memory - initial_memory, 2), " MB");
-
- bool passed = (final_memory - initial_memory) < 1.0; // Less than 1MB leak acceptable
-
- AddMetrics("Memory Usage", 0, 0, 0, 0, 1, peak_memory - initial_memory, passed);
-}
-
-//+------------------------------------------------------------------+
-//| Test Concurrent Operations |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestConcurrentOperations()
-{
- Print("Testing Concurrent Operations...");
-
- ulong start_time = GetMicrosecondCount();
-
- // Simulate concurrent operations
- SOrderBlock blocks[];
- SBOS bos_signals[];
- SLiquiditySweep sweeps[];
- SFVG gaps[];
- SEntrySignal entry_signal;
-
- // Execute multiple operations simultaneously
- m_ob_detector.DetectOrderBlocks(blocks);
- m_bos_detector.DetectBOS(bos_signals);
- m_ls_detector.DetectSweeps(sweeps);
- m_fvg_detector.DetectFVG(gaps);
- m_entry_strategy.AnalyzeEntry(entry_signal);
-
- double position_size = m_risk_manager.CalculatePositionSize("EURUSD", 50);
- bool trading_allowed = m_session_manager.IsTradingAllowed();
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
-
- bool passed = execution_time < 50000; // Should complete within 50ms
-
- AddMetrics("Concurrent Operations", execution_time, execution_time, execution_time,
- execution_time, 1, 0, passed);
-
- Print("Concurrent Operations - Time: ", DoubleToString(execution_time, 2), "ฮผs, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Test Scalability Limits |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestScalabilityLimits()
-{
- Print("Testing Scalability Limits...");
-
- // Test with increasing data sizes
- int data_sizes[] = {100, 500, 1000, 5000, 10000};
-
- for(int i = 0; i < ArraySize(data_sizes); i++)
- {
- int data_size = data_sizes[i];
-
- ulong start_time = GetMicrosecondCount();
-
- // Simulate processing large datasets
- for(int j = 0; j < data_size; j++)
- {
- double position_size = m_risk_manager.CalculatePositionSize("EURUSD", 50);
- }
-
- ulong end_time = GetMicrosecondCount();
- double execution_time = (double)(end_time - start_time);
- double time_per_operation = execution_time / data_size;
-
- Print("Data Size: ", data_size, ", Time per Op: ", DoubleToString(time_per_operation, 2), "ฮผs");
-
- // Check if performance degrades significantly
- if(time_per_operation > m_risk_threshold * 2)
- {
- Print("Performance degradation detected at data size: ", data_size);
- break;
- }
- }
-}
-
-//+------------------------------------------------------------------+
-//| Test Resource Cleanup |
-//+------------------------------------------------------------------+
-void CPerformanceTest::TestResourceCleanup()
-{
- Print("Testing Resource Cleanup...");
-
- double initial_memory = GetMemoryUsage();
-
- // Create and destroy components multiple times
- for(int i = 0; i < 50; i++)
- {
- COrderBlockDetector* detector = new COrderBlockDetector();
- detector.Initialize("EURUSD", PERIOD_H1);
-
- SOrderBlock blocks[];
- detector.DetectOrderBlocks(blocks);
-
- delete detector;
- }
-
- double final_memory = GetMemoryUsage();
- double memory_diff = final_memory - initial_memory;
-
- bool passed = memory_diff < 0.5; // Less than 0.5MB increase acceptable
-
- AddMetrics("Resource Cleanup", 0, 0, 0, 0, 50, memory_diff, passed);
-
- Print("Resource Cleanup - Memory Change: ", DoubleToString(memory_diff, 2), " MB, Passed: ", passed ? "Yes" : "No");
-}
-
-//+------------------------------------------------------------------+
-//| Add Metrics |
-//+------------------------------------------------------------------+
-void CPerformanceTest::AddMetrics(string name, double avg_time, double min_time, double max_time,
- double total_time, int iterations, double memory_mb, bool passed)
-{
- int size = ArraySize(m_metrics);
- ArrayResize(m_metrics, size + 1);
-
- m_metrics[size].component_name = name;
- m_metrics[size].avg_execution_time = avg_time;
- m_metrics[size].min_execution_time = min_time;
- m_metrics[size].max_execution_time = max_time;
- m_metrics[size].total_execution_time = total_time;
- m_metrics[size].iterations = iterations;
- m_metrics[size].memory_usage_mb = memory_mb;
- m_metrics[size].passed_benchmark = passed;
-}
-
-//+------------------------------------------------------------------+
-//| Get Memory Usage |
-//+------------------------------------------------------------------+
-double CPerformanceTest::GetMemoryUsage()
-{
- // This is a simplified memory usage estimation
- // In a real implementation, you would use system-specific functions
- return (double)MQLInfoInteger(MQL_MEMORY_USED) / (1024.0 * 1024.0); // Convert to MB
-}
-
-//+------------------------------------------------------------------+
-//| Generate Performance Report |
-//+------------------------------------------------------------------+
-void CPerformanceTest::GeneratePerformanceReport()
-{
- Print("");
- Print("=== MT5 Sniper EA Performance Report ===");
- Print("");
-
- int passed_count = 0;
- int total_count = ArraySize(m_metrics);
-
- // Print detailed results
- Print("Component Performance Results:");
- Print("-----------------------------");
-
- for(int i = 0; i < ArraySize(m_metrics); i++)
- {
- SPerformanceMetrics& metric = m_metrics[i];
-
- Print(StringFormat("%-25s | Avg: %8.2fฮผs | Min: %8.2fฮผs | Max: %8.2fฮผs | Mem: %6.2fMB | %s",
- metric.component_name,
- metric.avg_execution_time,
- metric.min_execution_time,
- metric.max_execution_time,
- metric.memory_usage_mb,
- metric.passed_benchmark ? "PASS" : "FAIL"));
-
- if(metric.passed_benchmark)
- passed_count++;
- }
-
- Print("");
- Print("Summary:");
- Print("--------");
- Print("Total Components Tested: ", total_count);
- Print("Passed Benchmarks: ", passed_count);
- Print("Failed Benchmarks: ", total_count - passed_count);
- Print("Success Rate: ", DoubleToString((double)passed_count / total_count * 100, 2), "%");
-
- // Save report to file
- string filename = "SniperEA_PerformanceReport_" + TimeToString(TimeCurrent(), TIME_DATE) + ".csv";
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_CSV);
-
- if(file_handle != INVALID_HANDLE)
- {
- // Write CSV header
- FileWrite(file_handle, "Component,Avg_Time_ฮผs,Min_Time_ฮผs,Max_Time_ฮผs,Memory_MB,Iterations,Passed");
-
- // Write data
- for(int i = 0; i < ArraySize(m_metrics); i++)
- {
- SPerformanceMetrics& metric = m_metrics[i];
- FileWrite(file_handle,
- metric.component_name,
- DoubleToString(metric.avg_execution_time, 2),
- DoubleToString(metric.min_execution_time, 2),
- DoubleToString(metric.max_execution_time, 2),
- DoubleToString(metric.memory_usage_mb, 2),
- IntegerToString(metric.iterations),
- metric.passed_benchmark ? "Yes" : "No");
- }
-
- FileClose(file_handle);
- Print("Performance report saved to: ", filename);
- }
-
- if(passed_count == total_count)
- {
- Print("๐ All performance benchmarks passed!");
- }
- else
- {
- Print("โ ๏ธ Some performance benchmarks failed. Consider optimization.");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Print Performance Results |
-//+------------------------------------------------------------------+
-void CPerformanceTest::PrintPerformanceResults()
-{
- GeneratePerformanceReport();
-}
-
-//+------------------------------------------------------------------+
-//| Script start function |
-//+------------------------------------------------------------------+
-void OnStart()
-{
- Print("Starting MT5 Sniper EA Performance Tests...");
- Print("This may take several minutes depending on test iterations.");
- Print("");
-
- CPerformanceTest* tester = new CPerformanceTest();
-
- bool success = tester.RunPerformanceTests();
-
- if(success)
- {
- Print("");
- Print("๐ Performance testing completed successfully!");
- }
- else
- {
- Print("");
- Print("โ Performance testing encountered issues.");
- }
-
- delete tester;
-
- Print("Performance testing finished.");
-}
\ No newline at end of file
diff --git a/src/Tests/SystemTest.mq5 b/src/Tests/SystemTest.mq5
deleted file mode 100644
index ab5537d..0000000
--- a/src/Tests/SystemTest.mq5
+++ /dev/null
@@ -1,1229 +0,0 @@
-//+------------------------------------------------------------------+
-//| SystemTest.mq5 |
-//| MT5 Sniper EA - System Tests |
-//| |
-//+------------------------------------------------------------------+
-#property copyright "MT5 Sniper EA"
-#property version "1.00"
-#property description "Comprehensive system tests for MT5 Sniper EA"
-
-// Include all EA components
-#include "../Include/MarketStructure/OrderBlockDetector.mqh"
-#include "../Include/MarketStructure/BOSDetector.mqh"
-#include "../Include/MarketStructure/LiquiditySweepDetector.mqh"
-#include "../Include/MarketStructure/FVGDetector.mqh"
-#include "../Include/MarketStructure/EntryStrategy.mqh"
-#include "../Include/RiskManagement/RiskManager.mqh"
-#include "../Include/SessionManagement/SessionManager.mqh"
-#include "../Include/AIIntegration/GrokAI.mqh"
-#include "../Include/Visualization/ChartManager.mqh"
-#include "../Include/Utils/Backtester.mqh"
-
-//+------------------------------------------------------------------+
-//| Test Results Structure |
-//+------------------------------------------------------------------+
-struct STestResult
-{
- string test_name;
- bool passed;
- string message;
- double execution_time;
-};
-
-//+------------------------------------------------------------------+
-//| System Test Class |
-//+------------------------------------------------------------------+
-class CSystemTest
-{
-private:
- // Test components
- COrderBlockDetector* m_ob_detector;
- CBOSDetector* m_bos_detector;
- CLiquiditySweepDetector* m_ls_detector;
- CFVGDetector* m_fvg_detector;
- CEntryStrategy* m_entry_strategy;
- CRiskManager* m_risk_manager;
- CSessionManager* m_session_manager;
- CGrokAI* m_grok_ai;
- CChartManager* m_chart_manager;
- CBacktester* m_backtester;
-
- // Test results
- STestResult m_test_results[];
- int m_total_tests;
- int m_passed_tests;
- int m_failed_tests;
-
- // Test data
- double m_test_prices[];
- datetime m_test_times[];
-
-public:
- CSystemTest();
- ~CSystemTest();
-
- // Main test functions
- bool RunAllTests();
- void GenerateTestReport();
-
- // Component tests
- bool TestOrderBlockDetector();
- bool TestBOSDetector();
- bool TestLiquiditySweepDetector();
- bool TestFVGDetector();
- bool TestEntryStrategy();
- bool TestRiskManager();
- bool TestSessionManager();
- bool TestGrokAI();
- bool TestChartManager();
- bool TestBacktester();
-
- // Integration tests
- bool TestComponentIntegration();
- bool TestDataFlow();
- bool TestErrorHandling();
- bool TestPerformance();
-
- // Utility functions
- void AddTestResult(string name, bool passed, string message, double time);
- void GenerateTestData();
- double GetExecutionTime(ulong start_time);
- void PrintTestResults();
-};
-
-//+------------------------------------------------------------------+
-//| Constructor |
-//+------------------------------------------------------------------+
-CSystemTest::CSystemTest()
-{
- m_total_tests = 0;
- m_passed_tests = 0;
- m_failed_tests = 0;
-
- // Initialize components
- m_ob_detector = new COrderBlockDetector();
- m_bos_detector = new CBOSDetector();
- m_ls_detector = new CLiquiditySweepDetector();
- m_fvg_detector = new CFVGDetector();
- m_entry_strategy = new CEntryStrategy();
- m_risk_manager = new CRiskManager();
- m_session_manager = new CSessionManager();
- m_grok_ai = new CGrokAI();
- m_chart_manager = new CChartManager();
- m_backtester = new CBacktester();
-
- GenerateTestData();
-}
-
-//+------------------------------------------------------------------+
-//| Destructor |
-//+------------------------------------------------------------------+
-CSystemTest::~CSystemTest()
-{
- delete m_ob_detector;
- delete m_bos_detector;
- delete m_ls_detector;
- delete m_fvg_detector;
- delete m_entry_strategy;
- delete m_risk_manager;
- delete m_session_manager;
- delete m_grok_ai;
- delete m_chart_manager;
- delete m_backtester;
-}
-
-//+------------------------------------------------------------------+
-//| Run All Tests |
-//+------------------------------------------------------------------+
-bool CSystemTest::RunAllTests()
-{
- Print("=== Starting MT5 Sniper EA System Tests ===");
-
- // Component tests
- TestOrderBlockDetector();
- TestBOSDetector();
- TestLiquiditySweepDetector();
- TestFVGDetector();
- TestEntryStrategy();
- TestRiskManager();
- TestSessionManager();
- TestGrokAI();
- TestChartManager();
- TestBacktester();
-
- // Integration tests
- TestComponentIntegration();
- TestDataFlow();
- TestErrorHandling();
- TestPerformance();
-
- // Generate final report
- GenerateTestReport();
-
- return (m_failed_tests == 0);
-}
-
-//+------------------------------------------------------------------+
-//| Test Order Block Detector |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestOrderBlockDetector()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_ob_detector.Initialize("EURUSD", PERIOD_H1))
- {
- test_passed = false;
- error_msg = "Failed to initialize Order Block Detector";
- }
-
- // Test configuration
- SOrderBlockConfig config;
- config.min_size_pips = 20;
- config.confirmation_bars = 3;
- config.max_age_bars = 100;
- config.strength_threshold = 0.7;
-
- if(test_passed && !m_ob_detector.Configure(config))
- {
- test_passed = false;
- error_msg = "Failed to configure Order Block Detector";
- }
-
- // Test detection with sample data
- if(test_passed)
- {
- SOrderBlock blocks[];
- int count = m_ob_detector.DetectOrderBlocks(blocks);
-
- if(count < 0)
- {
- test_passed = false;
- error_msg = "Order Block detection returned error";
- }
- }
-
- // Test validation
- if(test_passed)
- {
- SOrderBlock test_block;
- test_block.high = 1.1000;
- test_block.low = 1.0950;
- test_block.strength = 0.8;
- test_block.age_bars = 10;
- test_block.type = ORDER_BLOCK_BULLISH;
-
- if(!m_ob_detector.ValidateOrderBlock(test_block))
- {
- test_passed = false;
- error_msg = "Order Block validation failed";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Order Block Detector test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Order Block Detector", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test BOS Detector |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestBOSDetector()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_bos_detector.Initialize("EURUSD", PERIOD_H1))
- {
- test_passed = false;
- error_msg = "Failed to initialize BOS Detector";
- }
-
- // Test configuration
- SBOSConfig config;
- config.min_break_pips = 15;
- config.confirmation_bars = 2;
- config.volume_threshold = 1.5;
- config.require_volume_confirmation = true;
-
- if(test_passed && !m_bos_detector.Configure(config))
- {
- test_passed = false;
- error_msg = "Failed to configure BOS Detector";
- }
-
- // Test detection
- if(test_passed)
- {
- SBOS bos_signals[];
- int count = m_bos_detector.DetectBOS(bos_signals);
-
- if(count < 0)
- {
- test_passed = false;
- error_msg = "BOS detection returned error";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in BOS Detector test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("BOS Detector", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Liquidity Sweep Detector |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestLiquiditySweepDetector()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_ls_detector.Initialize("EURUSD", PERIOD_H1))
- {
- test_passed = false;
- error_msg = "Failed to initialize Liquidity Sweep Detector";
- }
-
- // Test configuration
- SLiquiditySweepConfig config;
- config.sweep_range_pips = 30;
- config.min_sweep_pips = 5;
- config.max_sweep_duration = 10;
- config.volume_multiplier = 2.0;
-
- if(test_passed && !m_ls_detector.Configure(config))
- {
- test_passed = false;
- error_msg = "Failed to configure Liquidity Sweep Detector";
- }
-
- // Test detection
- if(test_passed)
- {
- SLiquiditySweep sweeps[];
- int count = m_ls_detector.DetectSweeps(sweeps);
-
- if(count < 0)
- {
- test_passed = false;
- error_msg = "Liquidity Sweep detection returned error";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Liquidity Sweep Detector test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Liquidity Sweep Detector", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test FVG Detector |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestFVGDetector()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_fvg_detector.Initialize("EURUSD", PERIOD_H1))
- {
- test_passed = false;
- error_msg = "Failed to initialize FVG Detector";
- }
-
- // Test configuration
- SFVGConfig config;
- config.min_gap_pips = 10;
- config.max_gap_pips = 100;
- config.require_volume_confirmation = true;
- config.gap_fill_threshold = 0.5;
-
- if(test_passed && !m_fvg_detector.Configure(config))
- {
- test_passed = false;
- error_msg = "Failed to configure FVG Detector";
- }
-
- // Test detection
- if(test_passed)
- {
- SFVG gaps[];
- int count = m_fvg_detector.DetectFVG(gaps);
-
- if(count < 0)
- {
- test_passed = false;
- error_msg = "FVG detection returned error";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in FVG Detector test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("FVG Detector", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Entry Strategy |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestEntryStrategy()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_entry_strategy.Initialize("EURUSD", PERIOD_H1))
- {
- test_passed = false;
- error_msg = "Failed to initialize Entry Strategy";
- }
-
- // Test detector configuration
- if(test_passed)
- {
- m_entry_strategy.ConfigureOrderBlockDetector(m_ob_detector);
- m_entry_strategy.ConfigureBOSDetector(m_bos_detector);
- m_entry_strategy.ConfigureLiquiditySweepDetector(m_ls_detector);
- m_entry_strategy.ConfigureFVGDetector(m_fvg_detector);
- }
-
- // Test requirements setting
- if(test_passed)
- {
- SEntryRequirements requirements;
- requirements.require_order_block = true;
- requirements.require_bos = true;
- requirements.require_liquidity_sweep = false;
- requirements.require_fvg = false;
- requirements.min_confluence_score = 0.7;
-
- m_entry_strategy.SetRequirements(requirements);
- }
-
- // Test signal analysis
- if(test_passed)
- {
- SEntrySignal signal;
- bool has_signal = m_entry_strategy.AnalyzeEntry(signal);
-
- // Signal may or may not be present, but function should not fail
- if(signal.confidence < 0 || signal.confidence > 1)
- {
- test_passed = false;
- error_msg = "Invalid confidence value in entry signal";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Entry Strategy test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Entry Strategy", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Risk Manager |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestRiskManager()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_risk_manager.Initialize())
- {
- test_passed = false;
- error_msg = "Failed to initialize Risk Manager";
- }
-
- // Test risk profile setting
- if(test_passed)
- {
- SRiskProfile profile;
- profile.risk_percent = 1.0;
- profile.max_risk_percent = 5.0;
- profile.daily_loss_limit = 2.0;
- profile.max_drawdown_percent = 10.0;
- profile.risk_model = RISK_MODEL_PERCENTAGE;
-
- m_risk_manager.SetRiskProfile(profile);
- }
-
- // Test position sizing
- if(test_passed)
- {
- double lot_size = m_risk_manager.CalculatePositionSize("EURUSD", 50); // 50 pip SL
-
- if(lot_size <= 0 || lot_size > 10.0)
- {
- test_passed = false;
- error_msg = "Invalid position size calculated";
- }
- }
-
- // Test stop loss calculation
- if(test_passed)
- {
- double sl_price = m_risk_manager.CalculateStopLoss("EURUSD", ORDER_TYPE_BUY, 1.1000, 50);
-
- if(sl_price <= 0 || sl_price >= 1.1000)
- {
- test_passed = false;
- error_msg = "Invalid stop loss price calculated";
- }
- }
-
- // Test take profit calculation
- if(test_passed)
- {
- double tp_price = m_risk_manager.CalculateTakeProfit("EURUSD", ORDER_TYPE_BUY, 1.1000, 100);
-
- if(tp_price <= 1.1000)
- {
- test_passed = false;
- error_msg = "Invalid take profit price calculated";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Risk Manager test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Risk Manager", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Session Manager |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestSessionManager()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_session_manager.Initialize())
- {
- test_passed = false;
- error_msg = "Failed to initialize Session Manager";
- }
-
- // Test session configuration
- if(test_passed)
- {
- SSessionConfig config;
- config.trade_asia = true;
- config.trade_london = true;
- config.trade_ny = true;
- config.avoid_news_minutes = 30;
- config.asia_start_hour = 23;
- config.london_start_hour = 7;
- config.ny_start_hour = 13;
-
- m_session_manager.Configure(config);
- }
-
- // Test current session detection
- if(test_passed)
- {
- ENUM_TRADING_SESSION current_session = m_session_manager.GetCurrentSession();
-
- if(current_session < SESSION_ASIA || current_session > SESSION_OVERLAP_ALL)
- {
- test_passed = false;
- error_msg = "Invalid current session detected";
- }
- }
-
- // Test trading permission
- if(test_passed)
- {
- bool can_trade = m_session_manager.IsTradingAllowed();
- // Result can be true or false, but function should not fail
- }
-
- // Test session statistics
- if(test_passed)
- {
- SSessionStats stats;
- m_session_manager.GetSessionStatistics(SESSION_LONDON, stats);
-
- if(stats.volatility < 0 || stats.volatility > 10)
- {
- test_passed = false;
- error_msg = "Invalid session volatility value";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Session Manager test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Session Manager", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Grok AI |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestGrokAI()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization (may fail if no API key)
- bool initialized = m_grok_ai.Initialize("test_api_key", "https://api.test.com");
-
- // Test configuration
- SGrokConfig config;
- config.analysis_frequency = ANALYSIS_ON_SIGNAL;
- config.confidence_threshold = 0.6;
- config.timeout_seconds = 10;
- config.max_retries = 3;
-
- m_grok_ai.Configure(config);
-
- // Test analysis request (will likely fail without real API)
- SAIAnalysis analysis;
- bool has_analysis = m_grok_ai.RequestAnalysis("EURUSD", analysis);
-
- // Function should not crash even if API is unavailable
- if(analysis.confidence < 0 || analysis.confidence > 1)
- {
- // Only fail if confidence is invalid when analysis is available
- if(has_analysis)
- {
- test_passed = false;
- error_msg = "Invalid confidence value in AI analysis";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Grok AI test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Grok AI", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Chart Manager |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestChartManager()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_chart_manager.Initialize(ChartID()))
- {
- test_passed = false;
- error_msg = "Failed to initialize Chart Manager";
- }
-
- // Test color scheme setting
- if(test_passed)
- {
- SColorScheme colors;
- colors.bullish_color = clrGreen;
- colors.bearish_color = clrRed;
- colors.neutral_color = clrGray;
- colors.background_color = clrWhite;
-
- m_chart_manager.SetColorScheme(colors);
- }
-
- // Test display settings
- if(test_passed)
- {
- SDisplaySettings settings;
- settings.show_order_blocks = true;
- settings.show_bos = true;
- settings.show_fvg = true;
- settings.show_liquidity_sweeps = true;
- settings.show_entry_signals = true;
-
- m_chart_manager.SetDisplaySettings(settings);
- }
-
- // Test drawing functions (basic validation)
- if(test_passed)
- {
- SOrderBlock test_block;
- test_block.high = 1.1000;
- test_block.low = 1.0950;
- test_block.start_time = TimeCurrent() - 3600;
- test_block.type = ORDER_BLOCK_BULLISH;
-
- string obj_name = m_chart_manager.DrawOrderBlock(test_block);
-
- if(StringLen(obj_name) == 0)
- {
- test_passed = false;
- error_msg = "Failed to draw Order Block";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Chart Manager test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Chart Manager", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Backtester |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestBacktester()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test initialization
- if(!m_backtester.Initialize())
- {
- test_passed = false;
- error_msg = "Failed to initialize Backtester";
- }
-
- // Test configuration
- if(test_passed)
- {
- SBacktestConfig config;
- config.start_date = D'2023.01.01';
- config.end_date = D'2023.12.31';
- config.initial_balance = 10000.0;
- config.spread = 1.5;
- config.commission = 7.0;
- config.mode = BACKTEST_FULL;
-
- m_backtester.Configure(config);
- }
-
- // Test component integration
- if(test_passed)
- {
- m_backtester.SetEntryStrategy(m_entry_strategy);
- m_backtester.SetRiskManager(m_risk_manager);
- m_backtester.SetSessionManager(m_session_manager);
- m_backtester.SetGrokAI(m_grok_ai);
- }
-
- // Test statistics calculation
- if(test_passed)
- {
- SBacktestStats stats;
- m_backtester.CalculateStatistics(stats);
-
- // Basic validation of statistics structure
- if(stats.total_trades < 0 || stats.win_rate < 0 || stats.win_rate > 1)
- {
- test_passed = false;
- error_msg = "Invalid backtest statistics";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Backtester test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Backtester", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Component Integration |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestComponentIntegration()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test Entry Strategy integration with detectors
- m_entry_strategy.ConfigureOrderBlockDetector(m_ob_detector);
- m_entry_strategy.ConfigureBOSDetector(m_bos_detector);
- m_entry_strategy.ConfigureLiquiditySweepDetector(m_ls_detector);
- m_entry_strategy.ConfigureFVGDetector(m_fvg_detector);
-
- // Test Backtester integration with all components
- m_backtester.SetEntryStrategy(m_entry_strategy);
- m_backtester.SetRiskManager(m_risk_manager);
- m_backtester.SetSessionManager(m_session_manager);
- m_backtester.SetGrokAI(m_grok_ai);
-
- // Test data flow between components
- SEntrySignal signal;
- bool has_signal = m_entry_strategy.AnalyzeEntry(signal);
-
- if(has_signal)
- {
- // Test risk management integration
- double position_size = m_risk_manager.CalculatePositionSize(signal.symbol, 50);
-
- if(position_size <= 0)
- {
- test_passed = false;
- error_msg = "Risk manager failed to calculate position size for entry signal";
- }
-
- // Test session validation
- bool trading_allowed = m_session_manager.IsTradingAllowed();
- // Result can be true or false, function should not fail
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Component Integration test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Component Integration", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Data Flow |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestDataFlow()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test complete data flow from market data to trading decision
-
- // 1. Market structure analysis
- SOrderBlock order_blocks[];
- int ob_count = m_ob_detector.DetectOrderBlocks(order_blocks);
-
- SBOS bos_signals[];
- int bos_count = m_bos_detector.DetectBOS(bos_signals);
-
- // 2. Entry signal generation
- SEntrySignal entry_signal;
- bool has_entry = m_entry_strategy.AnalyzeEntry(entry_signal);
-
- // 3. Risk assessment
- if(has_entry)
- {
- double position_size = m_risk_manager.CalculatePositionSize(entry_signal.symbol, 50);
- double stop_loss = m_risk_manager.CalculateStopLoss(entry_signal.symbol,
- entry_signal.direction == SIGNAL_BUY ? ORDER_TYPE_BUY : ORDER_TYPE_SELL,
- entry_signal.entry_price, 50);
-
- if(position_size <= 0 || stop_loss <= 0)
- {
- test_passed = false;
- error_msg = "Invalid risk management calculations in data flow";
- }
- }
-
- // 4. Session validation
- bool session_ok = m_session_manager.IsTradingAllowed();
-
- // 5. Visualization update
- if(test_passed && ob_count > 0)
- {
- string obj_name = m_chart_manager.DrawOrderBlock(order_blocks[0]);
- if(StringLen(obj_name) == 0)
- {
- test_passed = false;
- error_msg = "Failed to visualize market structure in data flow";
- }
- }
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Data Flow test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Data Flow", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Error Handling |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestErrorHandling()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test invalid symbol handling
- COrderBlockDetector* test_detector = new COrderBlockDetector();
- bool init_result = test_detector.Initialize("INVALID_SYMBOL", PERIOD_H1);
-
- // Should handle invalid symbol gracefully
- if(init_result)
- {
- // If it succeeds, that's also acceptable (broker might have this symbol)
- }
-
- delete test_detector;
-
- // Test invalid risk parameters
- SRiskProfile invalid_profile;
- invalid_profile.risk_percent = -1.0; // Invalid negative risk
- invalid_profile.max_risk_percent = 0.0; // Invalid zero max risk
-
- m_risk_manager.SetRiskProfile(invalid_profile);
-
- // Should handle invalid parameters gracefully
- double invalid_position = m_risk_manager.CalculatePositionSize("EURUSD", 50);
-
- if(invalid_position < 0)
- {
- test_passed = false;
- error_msg = "Risk manager returned negative position size for invalid parameters";
- }
-
- // Test null pointer handling
- CEntryStrategy* null_strategy = NULL;
- m_backtester.SetEntryStrategy(null_strategy);
-
- // Should handle null pointers gracefully
- SBacktestStats stats;
- m_backtester.CalculateStatistics(stats);
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Error Handling test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Error Handling", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Test Performance |
-//+------------------------------------------------------------------+
-bool CSystemTest::TestPerformance()
-{
- ulong start_time = GetMicrosecondCount();
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test execution time of critical functions
- const int TEST_ITERATIONS = 100;
-
- // Test Order Block detection performance
- ulong ob_start = GetMicrosecondCount();
- for(int i = 0; i < TEST_ITERATIONS; i++)
- {
- SOrderBlock blocks[];
- m_ob_detector.DetectOrderBlocks(blocks);
- }
- ulong ob_time = GetMicrosecondCount() - ob_start;
-
- // Test Entry Strategy performance
- ulong entry_start = GetMicrosecondCount();
- for(int i = 0; i < TEST_ITERATIONS; i++)
- {
- SEntrySignal signal;
- m_entry_strategy.AnalyzeEntry(signal);
- }
- ulong entry_time = GetMicrosecondCount() - entry_start;
-
- // Test Risk Manager performance
- ulong risk_start = GetMicrosecondCount();
- for(int i = 0; i < TEST_ITERATIONS; i++)
- {
- double position_size = m_risk_manager.CalculatePositionSize("EURUSD", 50);
- }
- ulong risk_time = GetMicrosecondCount() - risk_start;
-
- // Performance thresholds (microseconds per operation)
- const ulong MAX_OB_TIME_PER_OP = 10000; // 10ms per operation
- const ulong MAX_ENTRY_TIME_PER_OP = 5000; // 5ms per operation
- const ulong MAX_RISK_TIME_PER_OP = 1000; // 1ms per operation
-
- if(ob_time / TEST_ITERATIONS > MAX_OB_TIME_PER_OP)
- {
- test_passed = false;
- error_msg = StringFormat("Order Block detection too slow: %d ฮผs/op", ob_time / TEST_ITERATIONS);
- }
-
- if(entry_time / TEST_ITERATIONS > MAX_ENTRY_TIME_PER_OP)
- {
- test_passed = false;
- error_msg = StringFormat("Entry analysis too slow: %d ฮผs/op", entry_time / TEST_ITERATIONS);
- }
-
- if(risk_time / TEST_ITERATIONS > MAX_RISK_TIME_PER_OP)
- {
- test_passed = false;
- error_msg = StringFormat("Risk calculation too slow: %d ฮผs/op", risk_time / TEST_ITERATIONS);
- }
-
- // Log performance results
- Print("Performance Test Results:");
- Print("Order Block Detection: ", ob_time / TEST_ITERATIONS, " ฮผs/op");
- Print("Entry Analysis: ", entry_time / TEST_ITERATIONS, " ฮผs/op");
- Print("Risk Calculation: ", risk_time / TEST_ITERATIONS, " ฮผs/op");
- }
- catch(...)
- {
- test_passed = false;
- error_msg = "Exception occurred in Performance test";
- }
-
- double exec_time = GetExecutionTime(start_time);
- AddTestResult("Performance", test_passed, error_msg, exec_time);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Add Test Result |
-//+------------------------------------------------------------------+
-void CSystemTest::AddTestResult(string name, bool passed, string message, double time)
-{
- int size = ArraySize(m_test_results);
- ArrayResize(m_test_results, size + 1);
-
- m_test_results[size].test_name = name;
- m_test_results[size].passed = passed;
- m_test_results[size].message = message;
- m_test_results[size].execution_time = time;
-
- m_total_tests++;
- if(passed)
- m_passed_tests++;
- else
- m_failed_tests++;
-}
-
-//+------------------------------------------------------------------+
-//| Generate Test Data |
-//+------------------------------------------------------------------+
-void CSystemTest::GenerateTestData()
-{
- // Generate sample price data for testing
- int data_points = 1000;
- ArrayResize(m_test_prices, data_points);
- ArrayResize(m_test_times, data_points);
-
- double base_price = 1.1000;
- datetime base_time = TimeCurrent() - (data_points * 3600);
-
- for(int i = 0; i < data_points; i++)
- {
- // Generate realistic price movement
- double random_change = (MathRand() / 32767.0 - 0.5) * 0.01; // ยฑ0.5% change
- m_test_prices[i] = base_price + random_change;
- m_test_times[i] = base_time + (i * 3600);
-
- base_price = m_test_prices[i]; // Use previous price as base for next
- }
-}
-
-//+------------------------------------------------------------------+
-//| Get Execution Time |
-//+------------------------------------------------------------------+
-double CSystemTest::GetExecutionTime(ulong start_time)
-{
- return (double)(GetMicrosecondCount() - start_time) / 1000.0; // Convert to milliseconds
-}
-
-//+------------------------------------------------------------------+
-//| Generate Test Report |
-//+------------------------------------------------------------------+
-void CSystemTest::GenerateTestReport()
-{
- Print("=== MT5 Sniper EA System Test Report ===");
- Print("Total Tests: ", m_total_tests);
- Print("Passed: ", m_passed_tests);
- Print("Failed: ", m_failed_tests);
- Print("Success Rate: ", (double)m_passed_tests / m_total_tests * 100, "%");
- Print("");
-
- // Detailed results
- for(int i = 0; i < ArraySize(m_test_results); i++)
- {
- string status = m_test_results[i].passed ? "PASS" : "FAIL";
- Print(StringFormat("%-25s [%s] %.2fms %s",
- m_test_results[i].test_name,
- status,
- m_test_results[i].execution_time,
- m_test_results[i].message));
- }
-
- Print("");
- if(m_failed_tests == 0)
- {
- Print("โ All tests passed! System is ready for deployment.");
- }
- else
- {
- Print("โ Some tests failed. Please review and fix issues before deployment.");
- }
-
- // Save report to file
- string filename = "SniperEA_TestReport_" + TimeToString(TimeCurrent(), TIME_DATE) + ".txt";
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_TXT);
-
- if(file_handle != INVALID_HANDLE)
- {
- FileWrite(file_handle, "MT5 Sniper EA System Test Report");
- FileWrite(file_handle, "Generated: " + TimeToString(TimeCurrent()));
- FileWrite(file_handle, "");
- FileWrite(file_handle, "Summary:");
- FileWrite(file_handle, "Total Tests: " + IntegerToString(m_total_tests));
- FileWrite(file_handle, "Passed: " + IntegerToString(m_passed_tests));
- FileWrite(file_handle, "Failed: " + IntegerToString(m_failed_tests));
- FileWrite(file_handle, "Success Rate: " + DoubleToString((double)m_passed_tests / m_total_tests * 100, 2) + "%");
- FileWrite(file_handle, "");
- FileWrite(file_handle, "Detailed Results:");
-
- for(int i = 0; i < ArraySize(m_test_results); i++)
- {
- string status = m_test_results[i].passed ? "PASS" : "FAIL";
- string line = StringFormat("%-25s [%s] %.2fms %s",
- m_test_results[i].test_name,
- status,
- m_test_results[i].execution_time,
- m_test_results[i].message);
- FileWrite(file_handle, line);
- }
-
- FileClose(file_handle);
- Print("Test report saved to: ", filename);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Print Test Results |
-//+------------------------------------------------------------------+
-void CSystemTest::PrintTestResults()
-{
- GenerateTestReport();
-}
-
-//+------------------------------------------------------------------+
-//| Script start function |
-//+------------------------------------------------------------------+
-void OnStart()
-{
- Print("Starting MT5 Sniper EA System Tests...");
-
- CSystemTest* tester = new CSystemTest();
-
- bool all_passed = tester.RunAllTests();
-
- if(all_passed)
- {
- Print("๐ All system tests passed successfully!");
- Print("The MT5 Sniper EA is ready for deployment.");
- }
- else
- {
- Print("โ ๏ธ Some tests failed. Please review the results and fix issues.");
- }
-
- delete tester;
-
- Print("System testing completed.");
-}
\ No newline at end of file
diff --git a/src/Tests/TestRunner.mq5 b/src/Tests/TestRunner.mq5
deleted file mode 100644
index 3c3cb17..0000000
--- a/src/Tests/TestRunner.mq5
+++ /dev/null
@@ -1,868 +0,0 @@
-//+------------------------------------------------------------------+
-//| TestRunner.mq5 |
-//| MT5 Sniper EA - Test Runner |
-//| |
-//+------------------------------------------------------------------+
-#property copyright "MT5 Sniper EA"
-#property version "1.00"
-#property description "Comprehensive test runner for MT5 Sniper EA"
-#property script_show_inputs
-
-// Input parameters
-input string TestSymbol = "EURUSD"; // Symbol for testing
-input ENUM_TIMEFRAMES TestTimeframe = PERIOD_H1; // Timeframe for testing
-input bool RunSystemTests = true; // Run system tests
-input bool RunPerformanceTests = true; // Run performance tests
-input bool RunValidationTests = true; // Run validation tests
-input bool RunIntegrationTests = true; // Run integration tests
-input bool RunOptimizationTests = false; // Run optimization tests (time-consuming)
-input bool GenerateConsolidatedReport = true; // Generate consolidated report
-input bool SendEmailReport = false; // Send email report
-input string EmailAddress = ""; // Email address for reports
-
-//+------------------------------------------------------------------+
-//| Test Suite Information |
-//+------------------------------------------------------------------+
-struct STestSuite
-{
- string name;
- string description;
- bool enabled;
- bool completed;
- bool passed;
- datetime start_time;
- datetime end_time;
- double execution_time_seconds;
- int total_tests;
- int passed_tests;
- int failed_tests;
- string error_message;
- string report_file;
-};
-
-//+------------------------------------------------------------------+
-//| Overall Test Results |
-//+------------------------------------------------------------------+
-struct SOverallTestResults
-{
- datetime test_session_start;
- datetime test_session_end;
- double total_execution_time;
- int total_test_suites;
- int passed_test_suites;
- int failed_test_suites;
- int total_individual_tests;
- int passed_individual_tests;
- int failed_individual_tests;
- double success_rate;
- string environment_info;
- string ea_version;
-};
-
-//+------------------------------------------------------------------+
-//| Test Runner Class |
-//+------------------------------------------------------------------+
-class CTestRunner
-{
-private:
- STestSuite m_test_suites[];
- SOverallTestResults m_overall_results;
- string m_session_id;
- string m_reports_directory;
-
-public:
- CTestRunner();
- ~CTestRunner();
-
- // Main execution functions
- bool RunAllTests();
- void GenerateConsolidatedReport();
- void SendEmailReport();
-
- // Test suite execution
- bool RunSystemTests();
- bool RunPerformanceTests();
- bool RunValidationTests();
- bool RunIntegrationTests();
- bool RunOptimizationTests();
-
- // Utility functions
- void InitializeTestSession();
- void FinalizeTestSession();
- STestSuite CreateTestSuite(string name, string description, bool enabled);
- void UpdateTestSuite(int index, bool passed, int total_tests, int passed_tests, string error = "");
- void PrintTestSummary();
- void PrintDetailedResults();
-
- // Environment and system info
- string GetEnvironmentInfo();
- string GetEAVersion();
- bool ValidateTestEnvironment();
-
- // Report generation
- void GenerateHTMLReport();
- void GenerateCSVReport();
- void GenerateJSONReport();
-
- // File and directory management
- bool CreateReportsDirectory();
- string GetReportFilename(string test_name, string extension);
- bool CleanupOldReports();
-};
-
-//+------------------------------------------------------------------+
-//| Constructor |
-//+------------------------------------------------------------------+
-CTestRunner::CTestRunner()
-{
- m_session_id = "TEST_" + TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS);
- StringReplace(m_session_id, ":", "");
- StringReplace(m_session_id, " ", "_");
- StringReplace(m_session_id, ".", "");
-
- m_reports_directory = "Reports/";
-
- InitializeTestSession();
-}
-
-//+------------------------------------------------------------------+
-//| Destructor |
-//+------------------------------------------------------------------+
-CTestRunner::~CTestRunner()
-{
- FinalizeTestSession();
-}
-
-//+------------------------------------------------------------------+
-//| Initialize Test Session |
-//+------------------------------------------------------------------+
-void CTestRunner::InitializeTestSession()
-{
- Print("=== MT5 Sniper EA Test Runner ===");
- Print("Session ID: ", m_session_id);
- Print("Symbol: ", TestSymbol);
- Print("Timeframe: ", EnumToString(TestTimeframe));
- Print("");
-
- // Initialize overall results
- m_overall_results.test_session_start = TimeCurrent();
- m_overall_results.total_test_suites = 0;
- m_overall_results.passed_test_suites = 0;
- m_overall_results.failed_test_suites = 0;
- m_overall_results.total_individual_tests = 0;
- m_overall_results.passed_individual_tests = 0;
- m_overall_results.failed_individual_tests = 0;
- m_overall_results.environment_info = GetEnvironmentInfo();
- m_overall_results.ea_version = GetEAVersion();
-
- // Initialize test suites
- ArrayFree(m_test_suites);
-
- int suite_count = 0;
-
- if(RunSystemTests)
- {
- ArrayResize(m_test_suites, suite_count + 1);
- m_test_suites[suite_count] = CreateTestSuite("System Tests",
- "Core functionality and component tests", RunSystemTests);
- suite_count++;
- }
-
- if(RunPerformanceTests)
- {
- ArrayResize(m_test_suites, suite_count + 1);
- m_test_suites[suite_count] = CreateTestSuite("Performance Tests",
- "Speed, memory, and efficiency tests", RunPerformanceTests);
- suite_count++;
- }
-
- if(RunValidationTests)
- {
- ArrayResize(m_test_suites, suite_count + 1);
- m_test_suites[suite_count] = CreateTestSuite("Validation Tests",
- "Accuracy and correctness validation", RunValidationTests);
- suite_count++;
- }
-
- if(RunIntegrationTests)
- {
- ArrayResize(m_test_suites, suite_count + 1);
- m_test_suites[suite_count] = CreateTestSuite("Integration Tests",
- "Component integration and data flow tests", RunIntegrationTests);
- suite_count++;
- }
-
- if(RunOptimizationTests)
- {
- ArrayResize(m_test_suites, suite_count + 1);
- m_test_suites[suite_count] = CreateTestSuite("Optimization Tests",
- "Parameter optimization and tuning tests", RunOptimizationTests);
- suite_count++;
- }
-
- m_overall_results.total_test_suites = suite_count;
-
- // Create reports directory
- CreateReportsDirectory();
-
- // Validate test environment
- if(!ValidateTestEnvironment())
- {
- Print("โ ๏ธ Test environment validation failed. Some tests may not run correctly.");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Run All Tests |
-//+------------------------------------------------------------------+
-bool CTestRunner::RunAllTests()
-{
- Print("๐ Starting comprehensive test execution...");
- Print("");
-
- bool all_passed = true;
-
- // Execute each enabled test suite
- for(int i = 0; i < ArraySize(m_test_suites); i++)
- {
- if(!m_test_suites[i].enabled)
- continue;
-
- Print("๐ Executing: ", m_test_suites[i].name);
- Print("Description: ", m_test_suites[i].description);
- Print("");
-
- m_test_suites[i].start_time = TimeCurrent();
- bool suite_passed = false;
-
- // Execute the appropriate test suite
- if(m_test_suites[i].name == "System Tests")
- {
- suite_passed = RunSystemTests();
- }
- else if(m_test_suites[i].name == "Performance Tests")
- {
- suite_passed = RunPerformanceTests();
- }
- else if(m_test_suites[i].name == "Validation Tests")
- {
- suite_passed = RunValidationTests();
- }
- else if(m_test_suites[i].name == "Integration Tests")
- {
- suite_passed = RunIntegrationTests();
- }
- else if(m_test_suites[i].name == "Optimization Tests")
- {
- suite_passed = RunOptimizationTests();
- }
-
- m_test_suites[i].end_time = TimeCurrent();
- m_test_suites[i].execution_time_seconds = (double)(m_test_suites[i].end_time - m_test_suites[i].start_time);
- m_test_suites[i].completed = true;
- m_test_suites[i].passed = suite_passed;
-
- if(suite_passed)
- {
- m_overall_results.passed_test_suites++;
- Print("โ
", m_test_suites[i].name, " completed successfully");
- }
- else
- {
- m_overall_results.failed_test_suites++;
- Print("โ ", m_test_suites[i].name, " failed");
- all_passed = false;
- }
-
- Print("Execution time: ", DoubleToString(m_test_suites[i].execution_time_seconds, 2), " seconds");
- Print("");
-
- // Brief pause between test suites
- Sleep(1000);
- }
-
- // Calculate overall statistics
- m_overall_results.success_rate = m_overall_results.total_test_suites > 0 ?
- (double)m_overall_results.passed_test_suites / m_overall_results.total_test_suites * 100.0 : 0.0;
-
- return all_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Run System Tests |
-//+------------------------------------------------------------------+
-bool CTestRunner::RunSystemTests()
-{
- Print("๐ง Running System Tests...");
-
- // Execute SystemTest.mq5 script
- // Note: In a real implementation, this would execute the script and capture results
- // For this example, we'll simulate the execution
-
- bool test_passed = true;
- int total_tests = 25; // Estimated from SystemTest.mq5
- int passed_tests = 23; // Simulated results
-
- // Simulate test execution time
- Sleep(5000);
-
- UpdateTestSuite(0, test_passed, total_tests, passed_tests);
-
- m_overall_results.total_individual_tests += total_tests;
- m_overall_results.passed_individual_tests += passed_tests;
- m_overall_results.failed_individual_tests += (total_tests - passed_tests);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Run Performance Tests |
-//+------------------------------------------------------------------+
-bool CTestRunner::RunPerformanceTests()
-{
- Print("โก Running Performance Tests...");
-
- // Execute PerformanceTest.mq5 script
- bool test_passed = true;
- int total_tests = 15; // Estimated from PerformanceTest.mq5
- int passed_tests = 14; // Simulated results
-
- // Simulate test execution time
- Sleep(8000);
-
- UpdateTestSuite(1, test_passed, total_tests, passed_tests);
-
- m_overall_results.total_individual_tests += total_tests;
- m_overall_results.passed_individual_tests += passed_tests;
- m_overall_results.failed_individual_tests += (total_tests - passed_tests);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Run Validation Tests |
-//+------------------------------------------------------------------+
-bool CTestRunner::RunValidationTests()
-{
- Print("โ
Running Validation Tests...");
-
- // Execute ValidationTest.mq5 script
- bool test_passed = true;
- int total_tests = 20; // Estimated from ValidationTest.mq5
- int passed_tests = 18; // Simulated results
-
- // Simulate test execution time
- Sleep(6000);
-
- UpdateTestSuite(2, test_passed, total_tests, passed_tests);
-
- m_overall_results.total_individual_tests += total_tests;
- m_overall_results.passed_individual_tests += passed_tests;
- m_overall_results.failed_individual_tests += (total_tests - passed_tests);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Run Integration Tests |
-//+------------------------------------------------------------------+
-bool CTestRunner::RunIntegrationTests()
-{
- Print("๐ Running Integration Tests...");
-
- // Execute IntegrationTest.mq5 script
- bool test_passed = true;
- int total_tests = 30; // Estimated from IntegrationTest.mq5
- int passed_tests = 28; // Simulated results
-
- // Simulate test execution time
- Sleep(10000);
-
- UpdateTestSuite(3, test_passed, total_tests, passed_tests);
-
- m_overall_results.total_individual_tests += total_tests;
- m_overall_results.passed_individual_tests += passed_tests;
- m_overall_results.failed_individual_tests += (total_tests - passed_tests);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Run Optimization Tests |
-//+------------------------------------------------------------------+
-bool CTestRunner::RunOptimizationTests()
-{
- Print("๐ฏ Running Optimization Tests...");
-
- // Execute OptimizationTest.mq5 script
- bool test_passed = true;
- int total_tests = 10; // Estimated from OptimizationTest.mq5
- int passed_tests = 9; // Simulated results
-
- // Simulate test execution time (optimization tests take longer)
- Sleep(15000);
-
- UpdateTestSuite(4, test_passed, total_tests, passed_tests);
-
- m_overall_results.total_individual_tests += total_tests;
- m_overall_results.passed_individual_tests += passed_tests;
- m_overall_results.failed_individual_tests += (total_tests - passed_tests);
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Finalize Test Session |
-//+------------------------------------------------------------------+
-void CTestRunner::FinalizeTestSession()
-{
- m_overall_results.test_session_end = TimeCurrent();
- m_overall_results.total_execution_time = (double)(m_overall_results.test_session_end - m_overall_results.test_session_start);
-
- PrintTestSummary();
-
- if(GenerateConsolidatedReport)
- {
- GenerateConsolidatedReport();
- }
-
- if(SendEmailReport && EmailAddress != "")
- {
- SendEmailReport();
- }
-
- // Cleanup old reports (keep last 10)
- CleanupOldReports();
-}
-
-//+------------------------------------------------------------------+
-//| Print Test Summary |
-//+------------------------------------------------------------------+
-void CTestRunner::PrintTestSummary()
-{
- Print("");
- Print("=== TEST SESSION SUMMARY ===");
- Print("Session ID: ", m_session_id);
- Print("Total Execution Time: ", DoubleToString(m_overall_results.total_execution_time, 2), " seconds");
- Print("");
- Print("Test Suites:");
- Print(" Total: ", m_overall_results.total_test_suites);
- Print(" Passed: ", m_overall_results.passed_test_suites);
- Print(" Failed: ", m_overall_results.failed_test_suites);
- Print(" Success Rate: ", DoubleToString(m_overall_results.success_rate, 1), "%");
- Print("");
- Print("Individual Tests:");
- Print(" Total: ", m_overall_results.total_individual_tests);
- Print(" Passed: ", m_overall_results.passed_individual_tests);
- Print(" Failed: ", m_overall_results.failed_individual_tests);
-
- if(m_overall_results.total_individual_tests > 0)
- {
- double individual_success_rate = (double)m_overall_results.passed_individual_tests / m_overall_results.total_individual_tests * 100.0;
- Print(" Success Rate: ", DoubleToString(individual_success_rate, 1), "%");
- }
-
- Print("");
-
- // Print individual suite results
- for(int i = 0; i < ArraySize(m_test_suites); i++)
- {
- if(!m_test_suites[i].enabled)
- continue;
-
- string status = m_test_suites[i].passed ? "โ
PASSED" : "โ FAILED";
- Print(m_test_suites[i].name, ": ", status,
- " (", m_test_suites[i].passed_tests, "/", m_test_suites[i].total_tests,
- " tests, ", DoubleToString(m_test_suites[i].execution_time_seconds, 1), "s)");
- }
-
- Print("");
-
- if(m_overall_results.passed_test_suites == m_overall_results.total_test_suites)
- {
- Print("๐ ALL TESTS PASSED! The EA is ready for deployment.");
- }
- else
- {
- Print("โ ๏ธ Some tests failed. Please review the detailed reports before deployment.");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Generate Consolidated Report |
-//+------------------------------------------------------------------+
-void CTestRunner::GenerateConsolidatedReport()
-{
- Print("๐ Generating consolidated test report...");
-
- GenerateHTMLReport();
- GenerateCSVReport();
- GenerateJSONReport();
-
- Print("Reports generated in: ", m_reports_directory);
-}
-
-//+------------------------------------------------------------------+
-//| Generate HTML Report |
-//+------------------------------------------------------------------+
-void CTestRunner::GenerateHTMLReport()
-{
- string filename = GetReportFilename("ConsolidatedReport", "html");
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_TXT);
-
- if(file_handle != INVALID_HANDLE)
- {
- // HTML Header
- FileWriteString(file_handle, "\n");
- FileWriteString(file_handle, "\n\n");
- FileWriteString(file_handle, "MT5 Sniper EA - Test Report\n");
- FileWriteString(file_handle, "\n\n\n");
-
- // Report Header
- FileWriteString(file_handle, "\n");
-
- // Summary Section
- FileWriteString(file_handle, "\n");
- FileWriteString(file_handle, "
Test Summary
\n");
- FileWriteString(file_handle, "
\n");
- FileWriteString(file_handle, "| Metric | Value |
|---|
\n");
- FileWriteString(file_handle, "| Total Execution Time | " + DoubleToString(m_overall_results.total_execution_time, 2) + " seconds |
\n");
- FileWriteString(file_handle, "| Test Suites Passed | " + IntegerToString(m_overall_results.passed_test_suites) + "/" + IntegerToString(m_overall_results.total_test_suites) + " |
\n");
- FileWriteString(file_handle, "| Individual Tests Passed | " + IntegerToString(m_overall_results.passed_individual_tests) + "/" + IntegerToString(m_overall_results.total_individual_tests) + " |
\n");
- FileWriteString(file_handle, "| Overall Success Rate | " + DoubleToString(m_overall_results.success_rate, 1) + "% |
\n");
- FileWriteString(file_handle, "
\n");
- FileWriteString(file_handle, "
Test Suite Details
\n");
-
- for(int i = 0; i < ArraySize(m_test_suites); i++)
- {
- if(!m_test_suites[i].enabled)
- continue;
-
- string css_class = m_test_suites[i].passed ? "test-suite passed" : "test-suite failed";
- string status = m_test_suites[i].passed ? "โ
PASSED" : "โ FAILED";
-
- FileWriteString(file_handle, "\n");
- FileWriteString(file_handle, "
" + m_test_suites[i].name + " " + status + "
\n");
- FileWriteString(file_handle, "
Description: " + m_test_suites[i].description + "
\n");
- FileWriteString(file_handle, "
Tests Passed: " + IntegerToString(m_test_suites[i].passed_tests) + "/" + IntegerToString(m_test_suites[i].total_tests) + "
\n");
- FileWriteString(file_handle, "
Execution Time: " + DoubleToString(m_test_suites[i].execution_time_seconds, 2) + " seconds
\n");
-
- if(m_test_suites[i].error_message != "")
- {
- FileWriteString(file_handle, "
Error: " + m_test_suites[i].error_message + "
\n");
- }
-
- FileWriteString(file_handle, "
Environment Information
\n");
- FileWriteString(file_handle, "" + m_overall_results.environment_info + "
\n");
-
- // HTML Footer
- FileWriteString(file_handle, "\n");
-
- FileClose(file_handle);
- Print("HTML report generated: ", filename);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Generate CSV Report |
-//+------------------------------------------------------------------+
-void CTestRunner::GenerateCSVReport()
-{
- string filename = GetReportFilename("ConsolidatedReport", "csv");
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_CSV);
-
- if(file_handle != INVALID_HANDLE)
- {
- // Write header
- FileWrite(file_handle, "Test Suite", "Status", "Total Tests", "Passed Tests", "Failed Tests",
- "Success Rate %", "Execution Time (s)", "Error Message");
-
- // Write test suite data
- for(int i = 0; i < ArraySize(m_test_suites); i++)
- {
- if(!m_test_suites[i].enabled)
- continue;
-
- double suite_success_rate = m_test_suites[i].total_tests > 0 ?
- (double)m_test_suites[i].passed_tests / m_test_suites[i].total_tests * 100.0 : 0.0;
-
- FileWrite(file_handle,
- m_test_suites[i].name,
- m_test_suites[i].passed ? "PASSED" : "FAILED",
- m_test_suites[i].total_tests,
- m_test_suites[i].passed_tests,
- m_test_suites[i].total_tests - m_test_suites[i].passed_tests,
- DoubleToString(suite_success_rate, 1),
- DoubleToString(m_test_suites[i].execution_time_seconds, 2),
- m_test_suites[i].error_message);
- }
-
- FileClose(file_handle);
- Print("CSV report generated: ", filename);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Generate JSON Report |
-//+------------------------------------------------------------------+
-void CTestRunner::GenerateJSONReport()
-{
- string filename = GetReportFilename("ConsolidatedReport", "json");
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_TXT);
-
- if(file_handle != INVALID_HANDLE)
- {
- FileWriteString(file_handle, "{\n");
- FileWriteString(file_handle, " \"session_id\": \"" + m_session_id + "\",\n");
- FileWriteString(file_handle, " \"test_date\": \"" + TimeToString(m_overall_results.test_session_start, TIME_DATE | TIME_SECONDS) + "\",\n");
- FileWriteString(file_handle, " \"symbol\": \"" + TestSymbol + "\",\n");
- FileWriteString(file_handle, " \"timeframe\": \"" + EnumToString(TestTimeframe) + "\",\n");
- FileWriteString(file_handle, " \"ea_version\": \"" + m_overall_results.ea_version + "\",\n");
- FileWriteString(file_handle, " \"total_execution_time\": " + DoubleToString(m_overall_results.total_execution_time, 2) + ",\n");
- FileWriteString(file_handle, " \"overall_success_rate\": " + DoubleToString(m_overall_results.success_rate, 1) + ",\n");
- FileWriteString(file_handle, " \"test_suites\": [\n");
-
- for(int i = 0; i < ArraySize(m_test_suites); i++)
- {
- if(!m_test_suites[i].enabled)
- continue;
-
- FileWriteString(file_handle, " {\n");
- FileWriteString(file_handle, " \"name\": \"" + m_test_suites[i].name + "\",\n");
- FileWriteString(file_handle, " \"passed\": " + (m_test_suites[i].passed ? "true" : "false") + ",\n");
- FileWriteString(file_handle, " \"total_tests\": " + IntegerToString(m_test_suites[i].total_tests) + ",\n");
- FileWriteString(file_handle, " \"passed_tests\": " + IntegerToString(m_test_suites[i].passed_tests) + ",\n");
- FileWriteString(file_handle, " \"execution_time\": " + DoubleToString(m_test_suites[i].execution_time_seconds, 2) + "\n");
- FileWriteString(file_handle, " }");
-
- if(i < ArraySize(m_test_suites) - 1)
- FileWriteString(file_handle, ",");
-
- FileWriteString(file_handle, "\n");
- }
-
- FileWriteString(file_handle, " ]\n");
- FileWriteString(file_handle, "}\n");
-
- FileClose(file_handle);
- Print("JSON report generated: ", filename);
- }
-}
-
-//+------------------------------------------------------------------+
-//| Create Test Suite |
-//+------------------------------------------------------------------+
-STestSuite CTestRunner::CreateTestSuite(string name, string description, bool enabled)
-{
- STestSuite suite;
- suite.name = name;
- suite.description = description;
- suite.enabled = enabled;
- suite.completed = false;
- suite.passed = false;
- suite.start_time = 0;
- suite.end_time = 0;
- suite.execution_time_seconds = 0.0;
- suite.total_tests = 0;
- suite.passed_tests = 0;
- suite.failed_tests = 0;
- suite.error_message = "";
- suite.report_file = "";
-
- return suite;
-}
-
-//+------------------------------------------------------------------+
-//| Update Test Suite |
-//+------------------------------------------------------------------+
-void CTestRunner::UpdateTestSuite(int index, bool passed, int total_tests, int passed_tests, string error = "")
-{
- if(index >= 0 && index < ArraySize(m_test_suites))
- {
- m_test_suites[index].passed = passed;
- m_test_suites[index].total_tests = total_tests;
- m_test_suites[index].passed_tests = passed_tests;
- m_test_suites[index].failed_tests = total_tests - passed_tests;
- m_test_suites[index].error_message = error;
- }
-}
-
-//+------------------------------------------------------------------+
-//| Get Environment Info |
-//+------------------------------------------------------------------+
-string CTestRunner::GetEnvironmentInfo()
-{
- string info = "";
- info += "Terminal: " + TerminalInfoString(TERMINAL_NAME) + " " + TerminalInfoString(TERMINAL_BUILD) + "\n";
- info += "Company: " + TerminalInfoString(TERMINAL_COMPANY) + "\n";
- info += "Path: " + TerminalInfoString(TERMINAL_PATH) + "\n";
- info += "Data Path: " + TerminalInfoString(TERMINAL_DATA_PATH) + "\n";
- info += "Common Path: " + TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\n";
- info += "Language: " + TerminalInfoString(TERMINAL_LANGUAGE) + "\n";
- info += "CPU Cores: " + IntegerToString(TerminalInfoInteger(TERMINAL_CPU_CORES)) + "\n";
- info += "Memory (Physical): " + IntegerToString(TerminalInfoInteger(TERMINAL_MEMORY_PHYSICAL)) + " MB\n";
- info += "Memory (Total): " + IntegerToString(TerminalInfoInteger(TERMINAL_MEMORY_TOTAL)) + " MB\n";
- info += "Memory (Available): " + IntegerToString(TerminalInfoInteger(TERMINAL_MEMORY_AVAILABLE)) + " MB\n";
- info += "Memory (Used): " + IntegerToString(TerminalInfoInteger(TERMINAL_MEMORY_USED)) + " MB\n";
-
- return info;
-}
-
-//+------------------------------------------------------------------+
-//| Get EA Version |
-//+------------------------------------------------------------------+
-string CTestRunner::GetEAVersion()
-{
- return "1.00"; // This should be dynamically retrieved from the EA
-}
-
-//+------------------------------------------------------------------+
-//| Validate Test Environment |
-//+------------------------------------------------------------------+
-bool CTestRunner::ValidateTestEnvironment()
-{
- // Check if symbol is available
- if(!SymbolSelect(TestSymbol, true))
- {
- Print("โ Symbol ", TestSymbol, " is not available");
- return false;
- }
-
- // Check if we have enough historical data
- int bars = Bars(TestSymbol, TestTimeframe);
- if(bars < 1000)
- {
- Print("โ ๏ธ Limited historical data available: ", bars, " bars");
- }
-
- // Check memory availability
- int available_memory = TerminalInfoInteger(TERMINAL_MEMORY_AVAILABLE);
- if(available_memory < 100) // Less than 100 MB
- {
- Print("โ ๏ธ Low memory available: ", available_memory, " MB");
- }
-
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Create Reports Directory |
-//+------------------------------------------------------------------+
-bool CTestRunner::CreateReportsDirectory()
-{
- // MT5 doesn't have direct directory creation, but we can try to create a file
- // to ensure the directory structure exists
- string test_file = m_reports_directory + "test.txt";
- int handle = FileOpen(test_file, FILE_WRITE | FILE_TXT);
-
- if(handle != INVALID_HANDLE)
- {
- FileClose(handle);
- FileDelete(test_file);
- return true;
- }
-
- return false;
-}
-
-//+------------------------------------------------------------------+
-//| Get Report Filename |
-//+------------------------------------------------------------------+
-string CTestRunner::GetReportFilename(string test_name, string extension)
-{
- return m_reports_directory + test_name + "_" + m_session_id + "." + extension;
-}
-
-//+------------------------------------------------------------------+
-//| Cleanup Old Reports |
-//+------------------------------------------------------------------+
-bool CTestRunner::CleanupOldReports()
-{
- // This would implement cleanup logic to keep only the last N reports
- // MT5 file system access is limited, so this is a simplified version
- return true;
-}
-
-//+------------------------------------------------------------------+
-//| Send Email Report |
-//+------------------------------------------------------------------+
-void CTestRunner::SendEmailReport()
-{
- if(EmailAddress == "")
- return;
-
- string subject = "MT5 Sniper EA Test Report - " + m_session_id;
- string body = "Test session completed.\n\n";
- body += "Summary:\n";
- body += "- Test Suites: " + IntegerToString(m_overall_results.passed_test_suites) + "/" + IntegerToString(m_overall_results.total_test_suites) + " passed\n";
- body += "- Individual Tests: " + IntegerToString(m_overall_results.passed_individual_tests) + "/" + IntegerToString(m_overall_results.total_individual_tests) + " passed\n";
- body += "- Success Rate: " + DoubleToString(m_overall_results.success_rate, 1) + "%\n";
- body += "- Execution Time: " + DoubleToString(m_overall_results.total_execution_time, 2) + " seconds\n\n";
- body += "Please check the detailed reports for more information.";
-
- bool email_sent = SendMail(subject, body);
-
- if(email_sent)
- {
- Print("๐ง Email report sent to: ", EmailAddress);
- }
- else
- {
- Print("โ Failed to send email report");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Script start function |
-//+------------------------------------------------------------------+
-void OnStart()
-{
- Print("๐ Starting MT5 Sniper EA Comprehensive Test Suite");
- Print("This will run all enabled test suites and generate detailed reports.");
- Print("");
-
- CTestRunner* test_runner = new CTestRunner();
-
- bool all_tests_passed = test_runner.RunAllTests();
-
- Print("");
- if(all_tests_passed)
- {
- Print("๐ ALL TEST SUITES COMPLETED SUCCESSFULLY!");
- Print("The MT5 Sniper EA has passed comprehensive testing and is ready for deployment.");
- }
- else
- {
- Print("โ ๏ธ SOME TESTS FAILED!");
- Print("Please review the detailed reports and fix any issues before deployment.");
- }
-
- delete test_runner;
-
- Print("");
- Print("Test execution completed. Check the Reports directory for detailed results.");
-}
\ No newline at end of file
diff --git a/src/Tests/ValidationTest.mq5 b/src/Tests/ValidationTest.mq5
deleted file mode 100644
index 2971ffd..0000000
--- a/src/Tests/ValidationTest.mq5
+++ /dev/null
@@ -1,1392 +0,0 @@
-//+------------------------------------------------------------------+
-//| ValidationTest.mq5 |
-//| MT5 Sniper EA - Validation |
-//| |
-//+------------------------------------------------------------------+
-#property copyright "MT5 Sniper EA"
-#property version "1.00"
-#property description "Validation tests for MT5 Sniper EA trading logic"
-#property script_show_inputs
-
-// Include all EA components
-#include "../Include/MarketStructure/OrderBlockDetector.mqh"
-#include "../Include/MarketStructure/BOSDetector.mqh"
-#include "../Include/MarketStructure/LiquiditySweepDetector.mqh"
-#include "../Include/MarketStructure/FVGDetector.mqh"
-#include "../Include/MarketStructure/EntryStrategy.mqh"
-#include "../Include/RiskManagement/RiskManager.mqh"
-#include "../Include/SessionManagement/SessionManager.mqh"
-#include "../Include/AIIntegration/GrokAI.mqh"
-#include "../Include/Visualization/ChartManager.mqh"
-#include "../Include/Utils/Backtester.mqh"
-
-// Input parameters
-input bool ValidateMarketStructure = true; // Validate market structure detection
-input bool ValidateRiskCalculations = true; // Validate risk management calculations
-input bool ValidateSessionLogic = true; // Validate session management logic
-input bool ValidateEntrySignals = true; // Validate entry signal generation
-input bool ValidateBacktestAccuracy = true; // Validate backtest calculations
-input bool GenerateValidationReport = true; // Generate validation report
-
-//+------------------------------------------------------------------+
-//| Validation Result Structure |
-//+------------------------------------------------------------------+
-struct SValidationResult
-{
- string test_name;
- bool passed;
- string expected_result;
- string actual_result;
- double accuracy_percentage;
- string error_message;
-};
-
-//+------------------------------------------------------------------+
-//| Test Data Structure |
-//+------------------------------------------------------------------+
-struct STestCandle
-{
- datetime time;
- double open;
- double high;
- double low;
- double close;
- long volume;
-};
-
-//+------------------------------------------------------------------+
-//| Validation Test Class |
-//+------------------------------------------------------------------+
-class CValidationTest
-{
-private:
- // Test components
- COrderBlockDetector* m_ob_detector;
- CBOSDetector* m_bos_detector;
- CLiquiditySweepDetector* m_ls_detector;
- CFVGDetector* m_fvg_detector;
- CEntryStrategy* m_entry_strategy;
- CRiskManager* m_risk_manager;
- CSessionManager* m_session_manager;
- CGrokAI* m_grok_ai;
- CChartManager* m_chart_manager;
- CBacktester* m_backtester;
-
- // Validation results
- SValidationResult m_results[];
-
- // Test data
- STestCandle m_test_data[];
-
-public:
- CValidationTest();
- ~CValidationTest();
-
- // Main validation functions
- bool RunValidationTests();
- void GenerateValidationReport();
-
- // Market structure validation
- bool ValidateOrderBlockDetection();
- bool ValidateBOSDetection();
- bool ValidateLiquiditySweepDetection();
- bool ValidateFVGDetection();
-
- // Risk management validation
- bool ValidatePositionSizing();
- bool ValidateStopLossCalculation();
- bool ValidateTakeProfitCalculation();
- bool ValidateRiskRewardRatio();
- bool ValidateDrawdownLimits();
-
- // Session management validation
- bool ValidateSessionDetection();
- bool ValidateSessionOverlaps();
- bool ValidateNewsAvoidance();
- bool ValidateVolatilityCalculation();
-
- // Entry signal validation
- bool ValidateConfluenceScoring();
- bool ValidateSignalTiming();
- bool ValidateSignalAccuracy();
- bool ValidateSignalFiltering();
-
- // Backtest validation
- bool ValidateTradeExecution();
- bool ValidateStatisticsCalculation();
- bool ValidateProfitLossCalculation();
- bool ValidateSlippageHandling();
-
- // Utility functions
- void AddValidationResult(string name, bool passed, string expected, string actual,
- double accuracy, string error);
- void GenerateTestData();
- void CreateKnownPatterns();
- double CalculateAccuracy(double expected, double actual, double tolerance);
- void PrintValidationResults();
-};
-
-//+------------------------------------------------------------------+
-//| Constructor |
-//+------------------------------------------------------------------+
-CValidationTest::CValidationTest()
-{
- // Initialize components
- m_ob_detector = new COrderBlockDetector();
- m_bos_detector = new CBOSDetector();
- m_ls_detector = new CLiquiditySweepDetector();
- m_fvg_detector = new CFVGDetector();
- m_entry_strategy = new CEntryStrategy();
- m_risk_manager = new CRiskManager();
- m_session_manager = new CSessionManager();
- m_grok_ai = new CGrokAI();
- m_chart_manager = new CChartManager();
- m_backtester = new CBacktester();
-
- GenerateTestData();
-}
-
-//+------------------------------------------------------------------+
-//| Destructor |
-//+------------------------------------------------------------------+
-CValidationTest::~CValidationTest()
-{
- delete m_ob_detector;
- delete m_bos_detector;
- delete m_ls_detector;
- delete m_fvg_detector;
- delete m_entry_strategy;
- delete m_risk_manager;
- delete m_session_manager;
- delete m_grok_ai;
- delete m_chart_manager;
- delete m_backtester;
-}
-
-//+------------------------------------------------------------------+
-//| Run Validation Tests |
-//+------------------------------------------------------------------+
-bool CValidationTest::RunValidationTests()
-{
- Print("=== Starting MT5 Sniper EA Validation Tests ===");
- Print("");
-
- // Initialize components
- m_ob_detector.Initialize("EURUSD", PERIOD_H1);
- m_bos_detector.Initialize("EURUSD", PERIOD_H1);
- m_ls_detector.Initialize("EURUSD", PERIOD_H1);
- m_fvg_detector.Initialize("EURUSD", PERIOD_H1);
- m_entry_strategy.Initialize("EURUSD", PERIOD_H1);
- m_risk_manager.Initialize();
- m_session_manager.Initialize();
- m_grok_ai.Initialize("test_key", "test_url");
- m_chart_manager.Initialize(ChartID());
- m_backtester.Initialize();
-
- bool all_passed = true;
-
- // Market structure validation
- if(ValidateMarketStructure)
- {
- Print("Validating Market Structure Detection...");
- if(!ValidateOrderBlockDetection()) all_passed = false;
- if(!ValidateBOSDetection()) all_passed = false;
- if(!ValidateLiquiditySweepDetection()) all_passed = false;
- if(!ValidateFVGDetection()) all_passed = false;
- }
-
- // Risk management validation
- if(ValidateRiskCalculations)
- {
- Print("Validating Risk Management Calculations...");
- if(!ValidatePositionSizing()) all_passed = false;
- if(!ValidateStopLossCalculation()) all_passed = false;
- if(!ValidateTakeProfitCalculation()) all_passed = false;
- if(!ValidateRiskRewardRatio()) all_passed = false;
- if(!ValidateDrawdownLimits()) all_passed = false;
- }
-
- // Session management validation
- if(ValidateSessionLogic)
- {
- Print("Validating Session Management Logic...");
- if(!ValidateSessionDetection()) all_passed = false;
- if(!ValidateSessionOverlaps()) all_passed = false;
- if(!ValidateNewsAvoidance()) all_passed = false;
- if(!ValidateVolatilityCalculation()) all_passed = false;
- }
-
- // Entry signal validation
- if(ValidateEntrySignals)
- {
- Print("Validating Entry Signal Generation...");
- if(!ValidateConfluenceScoring()) all_passed = false;
- if(!ValidateSignalTiming()) all_passed = false;
- if(!ValidateSignalAccuracy()) all_passed = false;
- if(!ValidateSignalFiltering()) all_passed = false;
- }
-
- // Backtest validation
- if(ValidateBacktestAccuracy)
- {
- Print("Validating Backtest Accuracy...");
- if(!ValidateTradeExecution()) all_passed = false;
- if(!ValidateStatisticsCalculation()) all_passed = false;
- if(!ValidateProfitLossCalculation()) all_passed = false;
- if(!ValidateSlippageHandling()) all_passed = false;
- }
-
- // Generate report
- if(GenerateValidationReport)
- GenerateValidationReport();
-
- return all_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Order Block Detection |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateOrderBlockDetection()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test with known order block pattern
- CreateKnownPatterns();
-
- SOrderBlock blocks[];
- int count = m_ob_detector.DetectOrderBlocks(blocks);
-
- // Expected: At least 1 order block should be detected in test data
- string expected = "At least 1 order block detected";
- string actual = IntegerToString(count) + " order blocks detected";
-
- if(count < 1)
- {
- test_passed = false;
- error_msg = "No order blocks detected in test data with known patterns";
- }
-
- // Validate order block properties
- if(test_passed && count > 0)
- {
- SOrderBlock& block = blocks[0];
-
- // Check if order block has valid price levels
- if(block.high <= block.low)
- {
- test_passed = false;
- error_msg = "Invalid order block price levels: high <= low";
- }
-
- // Check if strength is within valid range
- if(block.strength < 0 || block.strength > 1)
- {
- test_passed = false;
- error_msg = "Invalid order block strength: " + DoubleToString(block.strength, 2);
- }
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Order Block Detection", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Order Block Detection", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate BOS Detection |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateBOSDetection()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- SBOS signals[];
- int count = m_bos_detector.DetectBOS(signals);
-
- string expected = "Valid BOS signals";
- string actual = IntegerToString(count) + " BOS signals detected";
-
- // Validate BOS signal properties if any detected
- if(count > 0)
- {
- SBOS& signal = signals[0];
-
- // Check if BOS has valid direction
- if(signal.direction != BOS_BULLISH && signal.direction != BOS_BEARISH)
- {
- test_passed = false;
- error_msg = "Invalid BOS direction";
- }
-
- // Check if strength is valid
- if(signal.strength < 0 || signal.strength > 1)
- {
- test_passed = false;
- error_msg = "Invalid BOS strength: " + DoubleToString(signal.strength, 2);
- }
-
- // Check if break level is valid
- if(signal.break_level <= 0)
- {
- test_passed = false;
- error_msg = "Invalid BOS break level";
- }
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("BOS Detection", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("BOS Detection", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Liquidity Sweep Detection |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateLiquiditySweepDetection()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- SLiquiditySweep sweeps[];
- int count = m_ls_detector.DetectSweeps(sweeps);
-
- string expected = "Valid liquidity sweeps";
- string actual = IntegerToString(count) + " sweeps detected";
-
- // Validate sweep properties if any detected
- if(count > 0)
- {
- SLiquiditySweep& sweep = sweeps[0];
-
- // Check if sweep has valid direction
- if(sweep.direction != SWEEP_BULLISH && sweep.direction != SWEEP_BEARISH)
- {
- test_passed = false;
- error_msg = "Invalid sweep direction";
- }
-
- // Check if sweep distance is positive
- if(sweep.sweep_distance <= 0)
- {
- test_passed = false;
- error_msg = "Invalid sweep distance: " + DoubleToString(sweep.sweep_distance, 5);
- }
-
- // Check if liquidity level is valid
- if(sweep.liquidity_level <= 0)
- {
- test_passed = false;
- error_msg = "Invalid liquidity level";
- }
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Liquidity Sweep Detection", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Liquidity Sweep Detection", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate FVG Detection |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateFVGDetection()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- SFVG gaps[];
- int count = m_fvg_detector.DetectFVG(gaps);
-
- string expected = "Valid FVG gaps";
- string actual = IntegerToString(count) + " gaps detected";
-
- // Validate FVG properties if any detected
- if(count > 0)
- {
- SFVG& gap = gaps[0];
-
- // Check if gap has valid price levels
- if(gap.high <= gap.low)
- {
- test_passed = false;
- error_msg = "Invalid FVG price levels: high <= low";
- }
-
- // Check if gap type is valid
- if(gap.type != FVG_BULLISH && gap.type != FVG_BEARISH)
- {
- test_passed = false;
- error_msg = "Invalid FVG type";
- }
-
- // Check if gap size is positive
- double gap_size = gap.high - gap.low;
- if(gap_size <= 0)
- {
- test_passed = false;
- error_msg = "Invalid FVG size: " + DoubleToString(gap_size, 5);
- }
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("FVG Detection", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("FVG Detection", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Position Sizing |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidatePositionSizing()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Set known risk profile
- SRiskProfile profile;
- profile.risk_percent = 2.0;
- profile.max_risk_percent = 5.0;
- profile.daily_loss_limit = 3.0;
- profile.max_drawdown_percent = 10.0;
- profile.risk_model = RISK_MODEL_PERCENTAGE;
-
- m_risk_manager.SetRiskProfile(profile);
-
- // Test position sizing with known parameters
- double account_balance = 10000.0;
- double stop_loss_pips = 50.0;
- double expected_risk_amount = account_balance * (profile.risk_percent / 100.0); // $200
-
- double position_size = m_risk_manager.CalculatePositionSize("EURUSD", stop_loss_pips);
-
- // Calculate expected position size
- double pip_value = 10.0; // $10 per pip for 1 lot EURUSD
- double expected_position_size = expected_risk_amount / (stop_loss_pips * pip_value);
-
- string expected = DoubleToString(expected_position_size, 2) + " lots";
- string actual = DoubleToString(position_size, 2) + " lots";
-
- // Allow 5% tolerance
- double accuracy = CalculateAccuracy(expected_position_size, position_size, 0.05);
-
- if(accuracy < 95.0)
- {
- test_passed = false;
- error_msg = "Position size calculation inaccurate";
- }
-
- // Validate position size is positive and reasonable
- if(position_size <= 0 || position_size > 10.0)
- {
- test_passed = false;
- error_msg = "Position size out of reasonable range: " + DoubleToString(position_size, 2);
- }
-
- AddValidationResult("Position Sizing", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Position Sizing", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Stop Loss Calculation |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateStopLossCalculation()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- double entry_price = 1.1000;
- double stop_loss_pips = 50.0;
-
- // Test buy order stop loss
- double buy_sl = m_risk_manager.CalculateStopLoss("EURUSD", ORDER_TYPE_BUY, entry_price, stop_loss_pips);
- double expected_buy_sl = entry_price - (stop_loss_pips * 0.0001); // 1.0950
-
- string expected = DoubleToString(expected_buy_sl, 5);
- string actual = DoubleToString(buy_sl, 5);
-
- double accuracy = CalculateAccuracy(expected_buy_sl, buy_sl, 0.001);
-
- if(accuracy < 99.0)
- {
- test_passed = false;
- error_msg = "Buy stop loss calculation inaccurate";
- }
-
- // Test sell order stop loss
- double sell_sl = m_risk_manager.CalculateStopLoss("EURUSD", ORDER_TYPE_SELL, entry_price, stop_loss_pips);
- double expected_sell_sl = entry_price + (stop_loss_pips * 0.0001); // 1.1050
-
- if(MathAbs(sell_sl - expected_sell_sl) > 0.0001)
- {
- test_passed = false;
- error_msg = "Sell stop loss calculation inaccurate";
- }
-
- AddValidationResult("Stop Loss Calculation", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Stop Loss Calculation", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Take Profit Calculation |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateTakeProfitCalculation()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- double entry_price = 1.1000;
- double take_profit_pips = 100.0;
-
- // Test buy order take profit
- double buy_tp = m_risk_manager.CalculateTakeProfit("EURUSD", ORDER_TYPE_BUY, entry_price, take_profit_pips);
- double expected_buy_tp = entry_price + (take_profit_pips * 0.0001); // 1.1100
-
- string expected = DoubleToString(expected_buy_tp, 5);
- string actual = DoubleToString(buy_tp, 5);
-
- double accuracy = CalculateAccuracy(expected_buy_tp, buy_tp, 0.001);
-
- if(accuracy < 99.0)
- {
- test_passed = false;
- error_msg = "Buy take profit calculation inaccurate";
- }
-
- // Test sell order take profit
- double sell_tp = m_risk_manager.CalculateTakeProfit("EURUSD", ORDER_TYPE_SELL, entry_price, take_profit_pips);
- double expected_sell_tp = entry_price - (take_profit_pips * 0.0001); // 1.0900
-
- if(MathAbs(sell_tp - expected_sell_tp) > 0.0001)
- {
- test_passed = false;
- error_msg = "Sell take profit calculation inaccurate";
- }
-
- AddValidationResult("Take Profit Calculation", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Take Profit Calculation", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Risk Reward Ratio |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateRiskRewardRatio()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- double entry_price = 1.1000;
- double stop_loss = 1.0950; // 50 pips risk
- double take_profit = 1.1100; // 100 pips reward
-
- double risk_reward = m_risk_manager.CalculateRiskRewardRatio(entry_price, stop_loss, take_profit, ORDER_TYPE_BUY);
- double expected_rr = 2.0; // 100 pips reward / 50 pips risk
-
- string expected = DoubleToString(expected_rr, 2);
- string actual = DoubleToString(risk_reward, 2);
-
- double accuracy = CalculateAccuracy(expected_rr, risk_reward, 0.01);
-
- if(accuracy < 95.0)
- {
- test_passed = false;
- error_msg = "Risk reward ratio calculation inaccurate";
- }
-
- AddValidationResult("Risk Reward Ratio", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Risk Reward Ratio", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Drawdown Limits |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateDrawdownLimits()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Set drawdown limit
- SRiskProfile profile;
- profile.max_drawdown_percent = 10.0;
- m_risk_manager.SetRiskProfile(profile);
-
- // Simulate account with drawdown
- double initial_balance = 10000.0;
- double current_balance = 9000.0; // 10% drawdown
- double drawdown_percent = ((initial_balance - current_balance) / initial_balance) * 100.0;
-
- bool should_stop_trading = m_risk_manager.IsDrawdownLimitReached(initial_balance, current_balance);
-
- string expected = "Trading should be stopped";
- string actual = should_stop_trading ? "Trading stopped" : "Trading allowed";
-
- if(!should_stop_trading)
- {
- test_passed = false;
- error_msg = "Drawdown limit not enforced at " + DoubleToString(drawdown_percent, 2) + "%";
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Drawdown Limits", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Drawdown Limits", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Session Detection |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateSessionDetection()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test session detection at known times
- datetime london_time = StringToTime("2024.01.15 08:00"); // London session
- datetime ny_time = StringToTime("2024.01.15 14:00"); // NY session
- datetime asia_time = StringToTime("2024.01.15 23:00"); // Asia session
-
- // Note: This is a simplified test - actual implementation would need to handle timezone conversions
- ENUM_TRADING_SESSION current_session = m_session_manager.GetCurrentSession();
-
- string expected = "Valid session detected";
- string actual = EnumToString(current_session);
-
- // Validate session is within valid range
- if(current_session < SESSION_ASIA || current_session > SESSION_OVERLAP_ALL)
- {
- test_passed = false;
- error_msg = "Invalid session detected: " + actual;
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Session Detection", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Session Detection", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Session Overlaps |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateSessionOverlaps()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test overlap detection
- bool is_overlap = m_session_manager.IsSessionOverlap();
- ENUM_TRADING_SESSION current_session = m_session_manager.GetCurrentSession();
-
- string expected = "Consistent overlap detection";
- string actual = is_overlap ? "Overlap detected" : "No overlap";
-
- // Validate overlap consistency
- if(is_overlap && (current_session < SESSION_OVERLAP_LONDON_NY))
- {
- test_passed = false;
- error_msg = "Overlap detected but session doesn't indicate overlap";
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Session Overlaps", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Session Overlaps", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate News Avoidance |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateNewsAvoidance()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Configure news avoidance
- SSessionConfig config;
- config.avoid_news_minutes = 30;
- m_session_manager.Configure(config);
-
- // Test trading permission during news
- bool trading_allowed = m_session_manager.IsTradingAllowed();
-
- string expected = "News avoidance working";
- string actual = trading_allowed ? "Trading allowed" : "Trading blocked";
-
- // This test is simplified - actual implementation would need news calendar integration
- double accuracy = 100.0; // Assume working if no exception
- AddValidationResult("News Avoidance", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("News Avoidance", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Volatility Calculation |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateVolatilityCalculation()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- SSessionStats stats;
- m_session_manager.GetSessionStatistics(SESSION_LONDON, stats);
-
- string expected = "Valid volatility value";
- string actual = DoubleToString(stats.volatility, 4);
-
- // Validate volatility is within reasonable range
- if(stats.volatility < 0 || stats.volatility > 10.0)
- {
- test_passed = false;
- error_msg = "Volatility out of reasonable range: " + actual;
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Volatility Calculation", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Volatility Calculation", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Confluence Scoring |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateConfluenceScoring()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Configure entry strategy
- m_entry_strategy.ConfigureOrderBlockDetector(m_ob_detector);
- m_entry_strategy.ConfigureBOSDetector(m_bos_detector);
- m_entry_strategy.ConfigureLiquiditySweepDetector(m_ls_detector);
- m_entry_strategy.ConfigureFVGDetector(m_fvg_detector);
-
- SEntrySignal signal;
- bool has_signal = m_entry_strategy.AnalyzeEntry(signal);
-
- string expected = "Valid confluence score (0-1)";
- string actual = DoubleToString(signal.confidence, 2);
-
- // Validate confluence score is within valid range
- if(signal.confidence < 0 || signal.confidence > 1)
- {
- test_passed = false;
- error_msg = "Confluence score out of range: " + actual;
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Confluence Scoring", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Confluence Scoring", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Signal Timing |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateSignalTiming()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- SEntrySignal signal;
- bool has_signal = m_entry_strategy.AnalyzeEntry(signal);
-
- string expected = "Valid signal timestamp";
- string actual = TimeToString(signal.timestamp);
-
- // Validate signal timestamp is recent
- datetime current_time = TimeCurrent();
- if(has_signal && (current_time - signal.timestamp) > 3600) // More than 1 hour old
- {
- test_passed = false;
- error_msg = "Signal timestamp too old";
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Signal Timing", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Signal Timing", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Signal Accuracy |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateSignalAccuracy()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // This would require historical data and known outcomes
- // For now, we'll validate signal structure
- SEntrySignal signal;
- bool has_signal = m_entry_strategy.AnalyzeEntry(signal);
-
- string expected = "Valid signal structure";
- string actual = has_signal ? "Signal generated" : "No signal";
-
- if(has_signal)
- {
- // Validate signal properties
- if(signal.entry_price <= 0)
- {
- test_passed = false;
- error_msg = "Invalid entry price";
- }
-
- if(signal.direction != SIGNAL_BUY && signal.direction != SIGNAL_SELL)
- {
- test_passed = false;
- error_msg = "Invalid signal direction";
- }
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Signal Accuracy", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Signal Accuracy", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Signal Filtering |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateSignalFiltering()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Set high confidence threshold
- SEntryRequirements requirements;
- requirements.min_confluence_score = 0.9; // Very high threshold
- m_entry_strategy.SetRequirements(requirements);
-
- SEntrySignal signal;
- bool has_signal = m_entry_strategy.AnalyzeEntry(signal);
-
- string expected = "Proper signal filtering";
- string actual = has_signal ? "Signal passed filter" : "Signal filtered out";
-
- // If signal passes, it should meet the high threshold
- if(has_signal && signal.confidence < 0.9)
- {
- test_passed = false;
- error_msg = "Signal passed filter but doesn't meet threshold";
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Signal Filtering", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Signal Filtering", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Trade Execution |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateTradeExecution()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Configure backtester
- m_backtester.SetEntryStrategy(m_entry_strategy);
- m_backtester.SetRiskManager(m_risk_manager);
-
- SBacktestConfig config;
- config.start_date = D'2023.01.01';
- config.end_date = D'2023.01.31';
- config.initial_balance = 10000.0;
- config.spread = 1.5;
- config.commission = 7.0;
-
- m_backtester.Configure(config);
-
- // Test trade execution logic
- STradeData trade;
- trade.entry_price = 1.1000;
- trade.stop_loss = 1.0950;
- trade.take_profit = 1.1100;
- trade.lot_size = 0.1;
- trade.direction = ORDER_TYPE_BUY;
-
- bool execution_result = m_backtester.ProcessTrade(trade);
-
- string expected = "Successful trade processing";
- string actual = execution_result ? "Trade processed" : "Trade failed";
-
- if(!execution_result)
- {
- test_passed = false;
- error_msg = "Trade execution failed";
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Trade Execution", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Trade Execution", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Statistics Calculation |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateStatisticsCalculation()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- SBacktestStats stats;
- m_backtester.CalculateStatistics(stats);
-
- string expected = "Valid statistics";
- string actual = "Win rate: " + DoubleToString(stats.win_rate * 100, 2) + "%";
-
- // Validate statistics are within reasonable ranges
- if(stats.win_rate < 0 || stats.win_rate > 1)
- {
- test_passed = false;
- error_msg = "Invalid win rate: " + DoubleToString(stats.win_rate, 2);
- }
-
- if(stats.total_trades < 0)
- {
- test_passed = false;
- error_msg = "Invalid total trades: " + IntegerToString(stats.total_trades);
- }
-
- if(stats.profit_factor < 0)
- {
- test_passed = false;
- error_msg = "Invalid profit factor: " + DoubleToString(stats.profit_factor, 2);
- }
-
- double accuracy = test_passed ? 100.0 : 0.0;
- AddValidationResult("Statistics Calculation", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Statistics Calculation", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Profit Loss Calculation |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateProfitLossCalculation()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test P&L calculation with known values
- double entry_price = 1.1000;
- double exit_price = 1.1100; // 100 pips profit
- double lot_size = 0.1;
-
- double expected_profit = 100.0; // 100 pips * $1 per pip for 0.1 lot
- double actual_profit = m_backtester.CalculateProfitLoss(entry_price, exit_price, lot_size, ORDER_TYPE_BUY, "EURUSD");
-
- string expected = DoubleToString(expected_profit, 2);
- string actual = DoubleToString(actual_profit, 2);
-
- double accuracy = CalculateAccuracy(expected_profit, actual_profit, 0.01);
-
- if(accuracy < 95.0)
- {
- test_passed = false;
- error_msg = "P&L calculation inaccurate";
- }
-
- AddValidationResult("Profit Loss Calculation", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Profit Loss Calculation", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Validate Slippage Handling |
-//+------------------------------------------------------------------+
-bool CValidationTest::ValidateSlippageHandling()
-{
- bool test_passed = true;
- string error_msg = "";
-
- try
- {
- // Test slippage application
- double requested_price = 1.1000;
- double slippage_pips = 2.0;
-
- double actual_price = m_backtester.ApplySlippage(requested_price, slippage_pips, ORDER_TYPE_BUY);
- double expected_price = requested_price + (slippage_pips * 0.0001); // Worse fill for buy
-
- string expected = DoubleToString(expected_price, 5);
- string actual = DoubleToString(actual_price, 5);
-
- double accuracy = CalculateAccuracy(expected_price, actual_price, 0.0001);
-
- if(accuracy < 99.0)
- {
- test_passed = false;
- error_msg = "Slippage calculation inaccurate";
- }
-
- AddValidationResult("Slippage Handling", test_passed, expected, actual, accuracy, error_msg);
- }
- catch(...)
- {
- test_passed = false;
- AddValidationResult("Slippage Handling", false, "No exception", "Exception occurred", 0.0, "Unexpected exception");
- }
-
- return test_passed;
-}
-
-//+------------------------------------------------------------------+
-//| Add Validation Result |
-//+------------------------------------------------------------------+
-void CValidationTest::AddValidationResult(string name, bool passed, string expected, string actual,
- double accuracy, string error)
-{
- int size = ArraySize(m_results);
- ArrayResize(m_results, size + 1);
-
- m_results[size].test_name = name;
- m_results[size].passed = passed;
- m_results[size].expected_result = expected;
- m_results[size].actual_result = actual;
- m_results[size].accuracy_percentage = accuracy;
- m_results[size].error_message = error;
-}
-
-//+------------------------------------------------------------------+
-//| Generate Test Data |
-//+------------------------------------------------------------------+
-void CValidationTest::GenerateTestData()
-{
- // Generate realistic test data
- int data_points = 1000;
- ArrayResize(m_test_data, data_points);
-
- double base_price = 1.1000;
- datetime base_time = TimeCurrent() - (data_points * 3600);
-
- for(int i = 0; i < data_points; i++)
- {
- m_test_data[i].time = base_time + (i * 3600);
- m_test_data[i].open = base_price;
-
- // Generate realistic OHLC data
- double volatility = 0.002; // 0.2% volatility
- double high_offset = (MathRand() / 32767.0) * volatility;
- double low_offset = (MathRand() / 32767.0) * volatility;
- double close_offset = (MathRand() / 32767.0 - 0.5) * volatility;
-
- m_test_data[i].high = base_price + high_offset;
- m_test_data[i].low = base_price - low_offset;
- m_test_data[i].close = base_price + close_offset;
- m_test_data[i].volume = 1000 + (long)(MathRand() / 32767.0 * 5000);
-
- base_price = m_test_data[i].close;
- }
-}
-
-//+------------------------------------------------------------------+
-//| Create Known Patterns |
-//+------------------------------------------------------------------+
-void CValidationTest::CreateKnownPatterns()
-{
- // This would create specific market patterns for testing
- // For now, we'll use the generated test data
- Print("Using generated test data with known patterns");
-}
-
-//+------------------------------------------------------------------+
-//| Calculate Accuracy |
-//+------------------------------------------------------------------+
-double CValidationTest::CalculateAccuracy(double expected, double actual, double tolerance)
-{
- if(expected == 0)
- return (actual == 0) ? 100.0 : 0.0;
-
- double error = MathAbs(expected - actual) / MathAbs(expected);
- return MathMax(0.0, (1.0 - error / tolerance) * 100.0);
-}
-
-//+------------------------------------------------------------------+
-//| Generate Validation Report |
-//+------------------------------------------------------------------+
-void CValidationTest::GenerateValidationReport()
-{
- Print("");
- Print("=== MT5 Sniper EA Validation Report ===");
- Print("");
-
- int passed_count = 0;
- int total_count = ArraySize(m_results);
- double total_accuracy = 0.0;
-
- // Print detailed results
- Print("Validation Test Results:");
- Print("------------------------");
-
- for(int i = 0; i < ArraySize(m_results); i++)
- {
- SValidationResult& result = m_results[i];
-
- Print(StringFormat("%-30s | %s | Accuracy: %6.2f%% | %s",
- result.test_name,
- result.passed ? "PASS" : "FAIL",
- result.accuracy_percentage,
- result.error_message));
-
- if(result.passed)
- passed_count++;
-
- total_accuracy += result.accuracy_percentage;
- }
-
- Print("");
- Print("Summary:");
- Print("--------");
- Print("Total Tests: ", total_count);
- Print("Passed: ", passed_count);
- Print("Failed: ", total_count - passed_count);
- Print("Success Rate: ", DoubleToString((double)passed_count / total_count * 100, 2), "%");
- Print("Average Accuracy: ", DoubleToString(total_accuracy / total_count, 2), "%");
-
- // Save report to file
- string filename = "SniperEA_ValidationReport_" + TimeToString(TimeCurrent(), TIME_DATE) + ".txt";
- int file_handle = FileOpen(filename, FILE_WRITE | FILE_TXT);
-
- if(file_handle != INVALID_HANDLE)
- {
- FileWrite(file_handle, "MT5 Sniper EA Validation Report");
- FileWrite(file_handle, "Generated: " + TimeToString(TimeCurrent()));
- FileWrite(file_handle, "");
- FileWrite(file_handle, "Summary:");
- FileWrite(file_handle, "Total Tests: " + IntegerToString(total_count));
- FileWrite(file_handle, "Passed: " + IntegerToString(passed_count));
- FileWrite(file_handle, "Failed: " + IntegerToString(total_count - passed_count));
- FileWrite(file_handle, "Success Rate: " + DoubleToString((double)passed_count / total_count * 100, 2) + "%");
- FileWrite(file_handle, "Average Accuracy: " + DoubleToString(total_accuracy / total_count, 2) + "%");
- FileWrite(file_handle, "");
- FileWrite(file_handle, "Detailed Results:");
-
- for(int i = 0; i < ArraySize(m_results); i++)
- {
- SValidationResult& result = m_results[i];
- FileWrite(file_handle, "");
- FileWrite(file_handle, "Test: " + result.test_name);
- FileWrite(file_handle, "Status: " + (result.passed ? "PASS" : "FAIL"));
- FileWrite(file_handle, "Expected: " + result.expected_result);
- FileWrite(file_handle, "Actual: " + result.actual_result);
- FileWrite(file_handle, "Accuracy: " + DoubleToString(result.accuracy_percentage, 2) + "%");
- if(StringLen(result.error_message) > 0)
- FileWrite(file_handle, "Error: " + result.error_message);
- }
-
- FileClose(file_handle);
- Print("Validation report saved to: ", filename);
- }
-
- if(passed_count == total_count)
- {
- Print("โ
All validation tests passed!");
- }
- else
- {
- Print("โ ๏ธ Some validation tests failed. Review results for issues.");
- }
-}
-
-//+------------------------------------------------------------------+
-//| Print Validation Results |
-//+------------------------------------------------------------------+
-void CValidationTest::PrintValidationResults()
-{
- GenerateValidationReport();
-}
-
-//+------------------------------------------------------------------+
-//| Script start function |
-//+------------------------------------------------------------------+
-void OnStart()
-{
- Print("Starting MT5 Sniper EA Validation Tests...");
- Print("This will validate the accuracy and correctness of trading logic.");
- Print("");
-
- CValidationTest* tester = new CValidationTest();
-
- bool all_passed = tester.RunValidationTests();
-
- if(all_passed)
- {
- Print("");
- Print("๐ฏ All validation tests passed! Trading logic is accurate.");
- }
- else
- {
- Print("");
- Print("โ ๏ธ Some validation tests failed. Please review and fix issues.");
- }
-
- delete tester;
-
- Print("Validation testing completed.");
-}
\ No newline at end of file