mql5/Experts/Archive/PME_TestRunner_Diagnostic.mq5

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                 PME_TestRunner_Diagnostic.mq5                    |
//|         Diagnostic Version to Identify Test Failures             |
//+------------------------------------------------------------------+
#property copyright "PME Test Runner Diagnostic v1.01"
#property version   "1.01"
#property description "Diagnostic testing system for ERMT PME"

// Include test suite and PME modules
#include "Modules_PME/DataTypes_PME.mqh"
#include "Modules_PME/Utilities_PME.mqh"
#include "Modules_PME/RiskManager_PME.mqh"
#include "Modules_PME/TechnicalAnalysis_PME_Merged.mqh"
#include "Modules_PME/PositionManager_PME.mqh"
#include "Modules_PME/PME_TestSuite_Fixed.mqh"

//+------------------------------------------------------------------+
//| Input Parameters                                                 |
//+------------------------------------------------------------------+
input bool     InpDiagnosticMode = true;           // Diagnostic Mode
input bool     InpTestComponents = true;           // Test Component Creation
input bool     InpTestInitialization = true;       // Test Initialization
input bool     InpTestBasicOperations = true;      // Test Basic Operations
input bool     InpCreateRealPositions = false;     // Create Real Positions

//+------------------------------------------------------------------+
//| Global Variables                                                 |
//+------------------------------------------------------------------+
CUtilities*         g_utils = NULL;
CRiskManager*       g_risk = NULL;
CTechnicalAnalysis* g_tech = NULL;
CPositionManager*   g_manager = NULL;
CPMETestSuite*      g_test_suite = NULL;

int                 g_tests_run = 0;
int                 g_tests_passed = 0;
int                 g_tests_failed = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    Print("========================================");
    Print("  PME DIAGNOSTIC TEST RUNNER v1.01");
    Print("========================================");
    Print("Starting diagnostic tests...\n");
    
    // Run diagnostic tests
    RunDiagnostics();
    
    // Report results
    GenerateDiagnosticReport();
    
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Run All Diagnostics                                              |
//+------------------------------------------------------------------+
void RunDiagnostics()
{
    Print("=== DIAGNOSTIC TEST SEQUENCE ===\n");
    
    // Test 1: Component Creation
    if(InpTestComponents)
    {
        Print("TEST 1: Component Creation");
        if(TestComponentCreation())
        {
            RecordTest("Component Creation", true);
            Print("  ' PASSED - All components created\n");
        }
        else
        {
            RecordTest("Component Creation", false);
            Print("  ' FAILED - Component creation failed\n");
            return; // Stop here if components can't be created
        }
    }
    
    // Test 2: Component Initialization
    if(InpTestInitialization)
    {
        Print("TEST 2: Component Initialization");
        if(TestComponentInitialization())
        {
            RecordTest("Component Initialization", true);
            Print("  ' PASSED - All components initialized\n");
        }
        else
        {
            RecordTest("Component Initialization", false);
            Print("  ' FAILED - Initialization failed\n");
            return; // Stop here if initialization fails
        }
    }
    
    // Test 3: Basic Operations
    if(InpTestBasicOperations)
    {
        Print("TEST 3: Basic Operations");
        if(TestBasicOperations())
        {
            RecordTest("Basic Operations", true);
            Print("  ' PASSED - Basic operations work\n");
        }
        else
        {
            RecordTest("Basic Operations", false);
            Print("  ' FAILED - Basic operations failed\n");
        }
    }
    
    // Test 4: Position Management (without creating real positions)
    Print("TEST 4: Position Management Functions");
    if(TestPositionManagementFunctions())
    {
        RecordTest("Position Management", true);
        Print("  ' PASSED - Position management functions work\n");
    }
    else
    {
        RecordTest("Position Management", false);
        Print("  ' FAILED - Position management functions failed\n");
    }
    
    // Test 5: Technical Indicators
    Print("TEST 5: Technical Indicators");
    if(TestTechnicalIndicators())
    {
        RecordTest("Technical Indicators", true);
        Print("  ' PASSED - Indicators work\n");
    }
    else
    {
        RecordTest("Technical Indicators", false);
        Print("  ' FAILED - Indicators failed\n");
    }
}

//+------------------------------------------------------------------+
//| Test Component Creation                                          |
//+------------------------------------------------------------------+
bool TestComponentCreation()
{
    bool all_created = true;
    
    // Test Utilities
    Print("  Creating CUtilities...");
    g_utils = new CUtilities();
    if(g_utils == NULL)
    {
        Print("    ' Failed to create CUtilities");
        all_created = false;
    }
    else
    {
        Print("    ' CUtilities created");
    }
    
    // Test RiskManager
    Print("  Creating CRiskManager...");
    g_risk = new CRiskManager();
    if(g_risk == NULL)
    {
        Print("    ' Failed to create CRiskManager");
        all_created = false;
    }
    else
    {
        Print("    ' CRiskManager created");
    }
    
    // Test TechnicalAnalysis
    Print("  Creating CTechnicalAnalysis...");
    g_tech = new CTechnicalAnalysis();
    if(g_tech == NULL)
    {
        Print("    ' Failed to create CTechnicalAnalysis");
        all_created = false;
    }
    else
    {
        Print("    ' CTechnicalAnalysis created");
    }
    
    // Test PositionManager
    Print("  Creating CPositionManager...");
    g_manager = new CPositionManager();
    if(g_manager == NULL)
    {
        Print("    ' Failed to create CPositionManager");
        all_created = false;
    }
    else
    {
        Print("    ' CPositionManager created");
    }
    
    // Test TestSuite
    Print("  Creating CPMETestSuite...");
    g_test_suite = new CPMETestSuite();
    if(g_test_suite == NULL)
    {
        Print("    ' Failed to create CPMETestSuite");
        all_created = false;
    }
    else
    {
        Print("    ' CPMETestSuite created");
    }
    
    return all_created;
}

//+------------------------------------------------------------------+
//| Test Component Initialization                                    |
//+------------------------------------------------------------------+
bool TestComponentInitialization()
{
    bool all_initialized = true;
    
    // Initialize Utilities
    Print("  Initializing Utilities...");
    if(g_utils != NULL)
    {
        if(g_utils.Initialize(LOG_INFO, false))
        {
            Print("    ' Utilities initialized");
        }
        else
        {
            Print("    ' Utilities initialization failed");
            all_initialized = false;
        }
    }
    else
    {
        Print("    ' Utilities is NULL");
        all_initialized = false;
    }
    
    // Initialize RiskManager
    Print("  Initializing RiskManager...");
    if(g_risk != NULL && g_utils != NULL)
    {
        if(g_risk.Initialize(g_utils, 2.0, 6.0, 20.0))
        {
            Print("    ' RiskManager initialized");
        }
        else
        {
            Print("    ' RiskManager initialization failed");
            all_initialized = false;
        }
    }
    else
    {
        Print("    ' RiskManager or dependencies are NULL");
        all_initialized = false;
    }
    
    // Initialize TechnicalAnalysis
    Print("  Initializing TechnicalAnalysis...");
    if(g_tech != NULL && g_utils != NULL)
    {
        if(g_tech.Initialize(g_utils))
        {
            Print("    ' TechnicalAnalysis initialized");
        }
        else
        {
            Print("    ' TechnicalAnalysis initialization failed");
            Print("    Note: This often fails if indicators can't be created");
            all_initialized = false;
        }
    }
    else
    {
        Print("    ' TechnicalAnalysis or dependencies are NULL");
        all_initialized = false;
    }
    
    // Initialize PositionManager
    Print("  Initializing PositionManager...");
    if(g_manager != NULL && g_utils != NULL && g_risk != NULL && g_tech != NULL)
    {
        if(g_manager.Initialize(g_utils, g_risk, g_tech, 999999))
        {
            Print("    ' PositionManager initialized");
        }
        else
        {
            Print("    ' PositionManager initialization failed");
            all_initialized = false;
        }
    }
    else
    {
        Print("    ' PositionManager or dependencies are NULL");
        all_initialized = false;
    }
    
    // Initialize TestSuite
    Print("  Initializing TestSuite...");
    if(g_test_suite != NULL && g_manager != NULL && g_utils != NULL)
    {
        if(g_test_suite.Initialize(g_manager, g_utils))
        {
            Print("    ' TestSuite initialized");
        }
        else
        {
            Print("    ' TestSuite initialization failed");
            all_initialized = false;
        }
    }
    else
    {
        Print("    ' TestSuite or dependencies are NULL");
        all_initialized = false;
    }
    
    return all_initialized;
}

//+------------------------------------------------------------------+
//| Test Basic Operations                                            |
//+------------------------------------------------------------------+
bool TestBasicOperations()
{
    bool all_passed = true;
    
    // Test logging
    Print("  Testing logging...");
    if(g_utils != NULL)
    {
        g_utils.Log("Test log message", LOG_INFO);
        Print("    ' Logging works");
    }
    else
    {
        Print("    ' Utils not available");
        all_passed = false;
    }
    
    // Test risk calculations
    Print("  Testing risk calculations...");
    if(g_risk != NULL)
    {
        double daily_loss = g_risk.GetDailyLoss();
        double drawdown = g_risk.GetDrawdown();
        Print(StringFormat("    Daily Loss: %.2f%%, Drawdown: %.2f%%", daily_loss, drawdown));
        
        if(daily_loss >= 0 && drawdown >= 0)
        {
            Print("    ' Risk calculations work");
        }
        else
        {
            Print("    ' Risk calculations returned invalid values");
            all_passed = false;
        }
    }
    else
    {
        Print("    ' RiskManager not available");
        all_passed = false;
    }
    
    // Test position scanning
    Print("  Testing position scanning...");
    if(g_manager != NULL)
    {
        g_manager.ScanForPositions();
        int count = g_manager.GetManagedCount();
        Print(StringFormat("    Found %d positions", count));
        Print("    ' Position scanning works");
    }
    else
    {
        Print("    ' PositionManager not available");
        all_passed = false;
    }
    
    return all_passed;
}

//+------------------------------------------------------------------+
//| Test Position Management Functions                               |
//+------------------------------------------------------------------+
bool TestPositionManagementFunctions()
{
    if(g_manager == NULL) return false;
    
    bool all_passed = true;
    
    // Test configuration
    Print("  Testing configuration...");
    ManagementConfig config;
    config.breakeven_enabled = true;
    config.breakeven_trigger = 20;
    config.trailing_method = TRAIL_ATR;
    g_manager.SetConfiguration(config);
    Print("    ' Configuration set");
    
    // Test metrics
    Print("  Testing metrics...");
    SessionMetrics metrics;
    g_manager.GetSessionMetrics(metrics);
    Print(StringFormat("    Session started: %s", TimeToString(metrics.session_start)));
    Print("    ' Metrics accessible");
    
    // Test risk assessment
    Print("  Testing risk assessment...");
    RiskAssessment assessment = g_manager.AssessPortfolioRisk();
    Print(StringFormat("    Risk level: %d", assessment.level));
    Print("    ' Risk assessment works");
    
    return all_passed;
}

//+------------------------------------------------------------------+
//| Test Technical Indicators                                        |
//+------------------------------------------------------------------+
bool TestTechnicalIndicators()
{
    if(g_tech == NULL) return false;
    
    bool all_passed = true;
    
    // Test ATR
    Print("  Testing ATR...");
    double atr = g_tech.GetATR(_Symbol);
    if(atr > 0)
    {
        Print(StringFormat("    ATR: %.5f", atr));
        Print("    ' ATR works");
    }
    else
    {
        Print("    ' ATR returned 0");
        all_passed = false;
    }
    
    // Test RSI
    Print("  Testing RSI...");
    double rsi = g_tech.GetRSI(_Symbol);
    if(rsi > 0 && rsi < 100)
    {
        Print(StringFormat("    RSI: %.2f", rsi));
        Print("    ' RSI works");
    }
    else
    {
        Print("    ' RSI returned invalid value");
        all_passed = false;
    }
    
    // Test Market Condition
    Print("  Testing market condition...");
    ENUM_MARKET_CONDITION condition = g_tech.GetMarketCondition(_Symbol);
    Print(StringFormat("    Market: %s", EnumToString(condition)));
    Print("    ' Market condition works");
    
    return all_passed;
}

//+------------------------------------------------------------------+
//| Record Test Result                                               |
//+------------------------------------------------------------------+
void RecordTest(string test_name, bool passed)
{
    g_tests_run++;
    if(passed)
        g_tests_passed++;
    else
        g_tests_failed++;
}

//+------------------------------------------------------------------+
//| Generate Diagnostic Report                                       |
//+------------------------------------------------------------------+
void GenerateDiagnosticReport()
{
    Print("\n========================================");
    Print("       DIAGNOSTIC REPORT");
    Print("========================================");
    Print(StringFormat("Tests Run: %d", g_tests_run));
    Print(StringFormat("Tests Passed: %d", g_tests_passed));
    Print(StringFormat("Tests Failed: %d", g_tests_failed));
    Print(StringFormat("Success Rate: %.1f%%", 
                      g_tests_run > 0 ? (double)g_tests_passed / g_tests_run * 100 : 0));
    
    Print("\n--- Diagnostic Summary ---");
    
    if(g_tests_failed == 0)
    {
        Print("' ALL DIAGNOSTIC TESTS PASSED");
        Print("The PME system appears to be functioning correctly.");
        Print("Try running the full test suite with real position testing.");
    }
    else
    {
        Print("L' DIAGNOSTIC TESTS FAILED");
        Print("\nLikely Issues:");
        
        if(g_tech == NULL || !TestTechnicalIndicators())
        {
            Print(""  Technical indicators failing - Check chart has enough history");
            Print(""  Try switching to a major pair (EURUSD) with H1 timeframe");
        }
        
        if(g_manager == NULL)
        {
            Print(""  Position manager not initializing - Check dependencies");
        }
        
        Print("\nRecommended Actions:");
        Print("1. Ensure chart has at least 100 bars of history");
        Print("2. Switch to EURUSD H1 timeframe");
        Print("3. Check Expert Advisors are enabled");
        Print("4. Verify AutoTrading is ON");
    }
    
    Print("========================================\n");
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    // Cleanup
    if(g_test_suite != NULL) { delete g_test_suite; g_test_suite = NULL; }
    if(g_manager != NULL) { delete g_manager; g_manager = NULL; }
    if(g_tech != NULL) { delete g_tech; g_tech = NULL; }
    if(g_risk != NULL) { delete g_risk; g_risk = NULL; }
    if(g_utils != NULL) { delete g_utils; g_utils = NULL; }
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Not used in diagnostic mode
}
//+------------------------------------------------------------------+