/**
 * @file internal_ramp_comprehensive_test.cpp
 * @brief Comprehensive internal ramp test suite for TMC51x0 (single motor)
 *
 * This file contains comprehensive testing for TMC51x0 driver covering:
 * - Core initialization and basic setup
 * - Motor control features (enable/disable, current, chopper, StealthChop, etc.)
 * - Ramp control features (positioning, velocity, ramp parameters)
 * - Diagnostics features (status, StallGuard2, lost steps, phase currents, etc.)
 * - Protection features (short circuit, overtemperature)
 *
 * Hardware Requirements:
 * - ESP32 development board
 * - TMC51x0 stepper motor driver (Evaluation Board)
 * - 17HS4401S-PG518 geared stepper motor (5.18:1 gearbox)
 * - AS5047U encoder
 * - Two reference switches (endstops)
 * - SPI connection between ESP32 and TMC51x0
 *
 * Configuration:
 * - Motor: 17HS4401S-PG518 (gearbox)
 * - Board: TMC51x0 Evaluation Kit
 * - Platform: Test Rig (with encoder and reference switches)
 * - Communication Mode: SPI Internal Ramp (SPI_MODE=HIGH, SD_MODE=LOW)
 *
 * @note Reference switches are configured but do NOT stop the motor unless
 *       directly testing that feature (test_reference_switch_configuration).
 *
 * @author Nebiyu Tadesse
 * @date 2025
 */

#include "tmc51x0.hpp"
#include "features/tmc51x0_units.hpp"
#include "test_config/esp32_tmc51x0_bus.hpp"
#include "test_config/esp32_tmc51x0_test_config.hpp"
#include "test_config/TestFramework.h"
#include "driver/gpio.h"
#include <memory>

static const char* TAG = "InternalRamp_Test";
static TestResults g_test_results;

//=============================================================================
// CONFIGURATION SELECTION - Unified Test Rig Selection
//=============================================================================
// Test rig selection (compile-time constant) - automatically selects motor, board, and platform
// CORE DRIVER TEST RIG: Uses 17HS4401S gearbox motor, TMC51x0 EVAL board, reference switches, encoder
static constexpr tmc51x0_test_config::TestRigType SELECTED_TEST_RIG = 
    tmc51x0_test_config::TestRigType::TEST_RIG_CORE_DRIVER;

// Test configuration constants
using Motor = tmc51x0_test_config::MotorConfig_17HS4401S;
using Test = tmc51x0_test_config::TestConfig_17HS4401S;

static constexpr uint8_t TEST_TOFF = Motor::TOFF;
static constexpr tmc51x0::MicrostepResolution TEST_MRES = Motor::MRES; // 256 microsteps
static constexpr float MICROSTEPS = 256.0f;
// Steps per revolution for unit conversions (Output Shaft full steps * Microsteps)
// 17HS4401S-PG518: 200 steps * 5.18 ratio * 256 microsteps = ~265,216 steps/rev
static constexpr float STEPS_PER_REV = static_cast<float>(Motor::OUTPUT_FULL_STEPS) * MICROSTEPS;
static constexpr float LEAD_SCREW_PITCH_MM = 2.0F; // Lead screw pitch (adjust for your setup)

// Test constants in physical units
static constexpr float TEST_MAX_SPEED_RPM = 60.0f; // 1 rev/s = 60 RPM
static constexpr float TEST_ACCELERATION_REV_S2 = 120.0f; // 2 rev/s² (reach 60 RPM in 0.5s)
static constexpr float TEST_DECELERATION_REV_S2 = 120.0f; // 2 rev/s²

//=============================================================================
// TEST SECTION CONFIGURATION
//=============================================================================
// Enable/disable specific test categories by setting to true or false

// Core tests
static constexpr bool ENABLE_INITIALIZATION_TESTS = true;
static constexpr bool ENABLE_REGISTER_ACCESS_TESTS = true;
static constexpr bool ENABLE_MOTOR_PARAMETER_TESTS = true;
static constexpr bool ENABLE_RAMP_PARAMETER_TESTS = true;
static constexpr bool ENABLE_GLOBAL_CONFIG_TESTS = true;

// Motor control tests
static constexpr bool ENABLE_ENABLE_DISABLE_TESTS = true;
static constexpr bool ENABLE_CURRENT_CONTROL_TESTS = true;
static constexpr bool ENABLE_CHOPPER_TESTS = true;
static constexpr bool ENABLE_STEALTHCHOP_TESTS = true;
static constexpr bool ENABLE_MODE_CHANGE_SPEED_TESTS = true;
static constexpr bool ENABLE_GLOBAL_SCALER_TESTS = true;
static constexpr bool ENABLE_FREEWHEELING_TESTS = true;
static constexpr bool ENABLE_COOLSTEP_TESTS = true;
static constexpr bool ENABLE_DCSTEP_TESTS = true;
static constexpr bool ENABLE_LUT_TESTS = true;
static constexpr bool ENABLE_MOTOR_SETUP_TESTS = true;

// Ramp control tests
static constexpr bool ENABLE_RAMP_MODE_TESTS = true;
static constexpr bool ENABLE_POSITION_CONTROL_TESTS = true;
static constexpr bool ENABLE_SPEED_CONTROL_TESTS = true;
static constexpr bool ENABLE_RAMP_PARAMETER_TESTS_RAMP = true;
static constexpr bool ENABLE_REFERENCE_SWITCH_TESTS = true;
static constexpr bool ENABLE_UNIT_CONVERSION_TESTS = true;

// Diagnostics tests
static constexpr bool ENABLE_DRIVER_STATUS_TESTS = true;
static constexpr bool ENABLE_STALLGUARD_TESTS = true;
static constexpr bool ENABLE_LOST_STEPS_TESTS = true;
static constexpr bool ENABLE_PHASE_CURRENT_TESTS = true;
static constexpr bool ENABLE_PWM_SCALE_TESTS = true;
static constexpr bool ENABLE_MICROSTEP_DIAGNOSTICS_TESTS = true;
static constexpr bool ENABLE_GPIO_TESTS = true;
static constexpr bool ENABLE_FACTORY_OTP_TESTS = true;
static constexpr bool ENABLE_UART_COUNT_TESTS = true;
static constexpr bool ENABLE_OFFSET_CALIBRATION_TESTS = true;
static constexpr bool ENABLE_SENSORLESS_HOMING_TESTS = true;
static constexpr bool ENABLE_OPEN_LOAD_TESTS = true;

// Protection tests
static constexpr bool ENABLE_SHORT_CIRCUIT_TESTS = true;
static constexpr bool ENABLE_OVERTEMPERATURE_TESTS = true;

// Encoder tests
static constexpr bool ENABLE_ENCODER_CONFIG_TESTS = true;
static constexpr bool ENABLE_ENCODER_RESOLUTION_TESTS = true;
static constexpr bool ENABLE_ENCODER_POSITION_TESTS = true;
static constexpr bool ENABLE_DEVIATION_DETECTION_TESTS = true;
static constexpr bool ENABLE_LATCHED_POSITION_TESTS = true;

//=============================================================================
// FORWARD DECLARATIONS
//=============================================================================

// Core tests
/**
 * @brief Test driver initialization and basic setup verification.
 * @return true if test passed, false otherwise
 */
bool test_driver_initialization() noexcept;

/**
 * @brief Test register read/write operations.
 * @return true if test passed, false otherwise
 */
bool test_register_read_write() noexcept;

/**
 * @brief Test motor parameter configuration and settings.
 * @return true if test passed, false otherwise
 */
bool test_motor_parameter_settings() noexcept;

/**
 * @brief Test ramp parameter configuration (speed, acceleration, etc.).
 * @return true if test passed, false otherwise
 */
bool test_ramp_parameter_settings() noexcept;

/**
 * @brief Test global configuration settings (GCONF register).
 * @return true if test passed, false otherwise
 */
bool test_global_configuration() noexcept;

// Motor control tests
/**
 * @brief Test motor enable/disable functionality.
 * @return true if test passed, false otherwise
 */
bool test_enable_disable() noexcept;

/**
 * @brief Test motor current control (IRUN/IHOLD settings).
 * @return true if test passed, false otherwise
 */
bool test_current_control() noexcept;

/**
 * @brief Test chopper configuration (SpreadCycle mode).
 * @return true if test passed, false otherwise
 */
bool test_chopper_configuration() noexcept;

/**
 * @brief Test StealthChop configuration and automatic tuning.
 * @return true if test passed, false otherwise
 */
bool test_stealthchop_configuration() noexcept;

/**
 * @brief Test mode change speed thresholds (PWM_THRS, COOL_THRS, HIGH_THRS).
 * @return true if test passed, false otherwise
 */
bool test_mode_change_speeds() noexcept;

/**
 * @brief Test global scaler configuration.
 * @return true if test passed, false otherwise
 */
bool test_global_scaler() noexcept;

/**
 * @brief Test freewheeling mode configuration.
 * @return true if test passed, false otherwise
 */
bool test_freewheeling_mode() noexcept;

/**
 * @brief Test CoolStep configuration and operation.
 * @return true if test passed, false otherwise
 */
bool test_coolstep_configuration() noexcept;

/**
 * @brief Test DCStep configuration and operation.
 * @return true if test passed, false otherwise
 */
bool test_dcstep_configuration() noexcept;

/**
 * @brief Test microstep lookup table configuration.
 * @return true if test passed, false otherwise
 */
bool test_microstep_lookup_table() noexcept;

/**
 * @brief Test motor setup from specifications (automatic configuration).
 * @return true if test passed, false otherwise
 */
bool test_motor_setup_from_spec() noexcept;

// Ramp control tests
/**
 * @brief Test ramp mode switching (POSITIONING, VELOCITY_POS, VELOCITY_NEG, HOLD).
 * @return true if test passed, false otherwise
 */
bool test_ramp_modes() noexcept;

/**
 * @brief Test position control (target position, current position).
 * @return true if test passed, false otherwise
 */
bool test_position_control() noexcept;

/**
 * @brief Test speed control (max speed, acceleration, deceleration).
 * @return true if test passed, false otherwise
 */
bool test_speed_control() noexcept;

/**
 * @brief Test ramp parameters (VSTART, VSTOP, first acceleration, etc.).
 * @return true if test passed, false otherwise
 */
bool test_ramp_parameters() noexcept;

/**
 * @brief Test reference switch configuration and homing.
 * @return true if test passed, false otherwise
 */
bool test_reference_switch_configuration() noexcept;

/**
 * @brief Test unit conversion functions (RPM, degrees, millimeters, etc.).
 * @return true if test passed, false otherwise
 */
bool test_unit_conversions() noexcept;

// Diagnostics tests
/**
 * @brief Test driver status reading (GSTAT, DRV_STATUS).
 * @return true if test passed, false otherwise
 */
bool test_driver_status() noexcept;

/**
 * @brief Test StallGuard2 configuration and reading.
 * @return true if test passed, false otherwise
 */
bool test_stallguard() noexcept;

/**
 * @brief Test lost steps detection and reading.
 * @return true if test passed, false otherwise
 */
bool test_lost_steps() noexcept;

/**
 * @brief Test phase current reading (microstep current diagnostics).
 * @return true if test passed, false otherwise
 */
bool test_phase_currents() noexcept;

/**
 * @brief Test PWM scale reading (PWM_AUTO, PWM_SCALE_SUM).
 * @return true if test passed, false otherwise
 */
bool test_pwm_scale() noexcept;

/**
 * @brief Test microstep diagnostics (counter, time between microsteps).
 * @return true if test passed, false otherwise
 */
bool test_microstep_diagnostics() noexcept;

/**
 * @brief Test GPIO pin reading functionality.
 * @return true if test passed, false otherwise
 */
bool test_gpio_pins() noexcept;

/**
 * @brief Test factory and OTP configuration reading.
 * @return true if test passed, false otherwise
 */
bool test_factory_otp_config() noexcept;

/**
 * @brief Test UART transmission count reading.
 * @return true if test passed, false otherwise
 */
bool test_uart_transmission_count() noexcept;

/**
 * @brief Test offset calibration reading.
 * @return true if test passed, false otherwise
 */
bool test_offset_calibration() noexcept;

/**
 * @brief Test sensorless homing configuration (StallGuard2-based).
 * @return true if test passed, false otherwise
 */
bool test_sensorless_homing() noexcept;

/**
 * @brief Test open load detection functionality.
 * @return true if test passed, false otherwise
 */
bool test_open_load() noexcept;

// Protection tests
/**
 * @brief Test short circuit protection configuration.
 * @return true if test passed, false otherwise
 */
bool test_short_circuit_protection() noexcept;

/**
 * @brief Test overtemperature protection status reading.
 * @return true if test passed, false otherwise
 */
bool test_overtemperature_protection() noexcept;

// Encoder tests
/**
 * @brief Test encoder configuration and setup.
 * @return true if test passed, false otherwise
 */
bool test_encoder_configuration() noexcept;

/**
 * @brief Test encoder resolution setting.
 * @return true if test passed, false otherwise
 */
bool test_encoder_resolution() noexcept;

/**
 * @brief Test encoder position reading.
 * @return true if test passed, false otherwise
 */
bool test_encoder_position_reading() noexcept;

/**
 * @brief Test encoder deviation detection and warnings.
 * @return true if test passed, false otherwise
 */
bool test_deviation_detection() noexcept;

/**
 * @brief Test latched position reading (index pulse).
 * @return true if test passed, false otherwise
 */
bool test_latched_position() noexcept;

//=============================================================================
// HELPER FUNCTIONS
//=============================================================================

/**
 * @brief Test driver handle containing SPI interface and driver instance.
 * 
 * @details
 * This structure holds the lifetime-managed SPI communication interface
 * and TMC51x0 driver instance for test functions. Uses unique_ptr for
 * automatic resource management.
 */
struct TestDriverHandle {
  std::unique_ptr<Esp32SPI> spi;  ///< SPI communication interface
  std::unique_ptr<tmc51x0::TMC51x0<Esp32SPI>> driver;  ///< TMC51x0 driver instance
};

/**
 * @brief Helper to calculate current register value (0-31) from mA
 * 
 * Converts target current in mA to IRUN/IHOLD register value (0-31) using
 * the TMC51x0 current calculation formula:
 * I_RMS = (GLOBAL_SCALER/256) * ((CS+1)/32) * (VFS/RSENSE) * (1/√2)
 * 
 * Reversed: CS = (I_RMS * 256 * 32) / (GLOBAL_SCALER * (VFS/RSENSE) * (1/√2)) - 1
 * 
 * NOTE: This is a TEST HELPER function, not part of the TMC51x0 driver API.
 * The driver's `SetCurrent()` method takes register values (0-31) directly.
 * The driver's `SetupMotorFromSpec()` handles mA-to-register conversion automatically
 * during initialization, but tests need fine-grained control over specific mA values,
 * hence this helper function.
 * 
 * @param current_ma Target current in mA
 * @param global_scaler Global scaler value (32-256). If 0, uses 256 (full scale)
 * @param sense_resistor_mohm Sense resistor value in mOhm. If 0, uses board config default
 * @return uint8_t Register value (0-31), clamped to valid range
 */
uint8_t CalculateCurrentRegister(uint16_t current_ma, uint16_t global_scaler = 0, 
                                uint32_t sense_resistor_mohm = 0) {
    // Get board constants if not provided
    if (sense_resistor_mohm == 0) {
        constexpr auto board_type = tmc51x0_test_config::GetTestRigBoardType<SELECTED_TEST_RIG>();
        if constexpr (board_type == tmc51x0_test_config::BoardType::BOARD_TMC51x0_EVAL) {
            sense_resistor_mohm = tmc51x0_test_config::BoardConfig_TMC51x0_EVAL::SENSE_RESISTOR_MOHM;
        } else {
            sense_resistor_mohm = tmc51x0_test_config::BoardConfig_TMC51x0_BOB::SENSE_RESISTOR_MOHM;
        }
    }
    
    if (global_scaler == 0) {
        global_scaler = 256; // Default to full scale
    }
    
    // Datasheet constants (working directly in millivolts and milliohms)
    constexpr float VFS_MV = 325.0f; // Full-scale voltage (mV) = 0.325V
    constexpr float SQRT2 = 1.41421356237f; // √2
    
    float global_scaler_norm = static_cast<float>(global_scaler) / 256.0f;
    
    // Calculate CS register value (working directly in milliamps and milliohms)
    // CS = (I_RMS_ma * 256 * 32) / (GLOBAL_SCALER * (VFS_mV/RSENSE_mΩ) * (1/√2)) - 1
    float cs_float = (static_cast<float>(current_ma) * 256.0f * 32.0f) / 
                     (global_scaler_norm * (VFS_MV / static_cast<float>(sense_resistor_mohm)) / SQRT2) - 1.0f;
    
    // Clamp to valid range (0-31)
    int32_t cs = static_cast<int32_t>(std::round(cs_float));
    if (cs < 0) cs = 0;
    if (cs > 31) cs = 31;
    
    return static_cast<uint8_t>(cs);
}

/**
 * @brief Verify mode pins match expected communication mode
 * @param spi SPI communication interface
 * @param driver TMC51x0 driver instance
 * @param expected_comm_mode Expected communication mode (SPI or UART)
 * @return true if verification passed or pins not configured, false on mismatch
 */
bool verify_mode_pins(const Esp32SPI& spi, const tmc51x0::TMC51x0<Esp32SPI>& driver, tmc51x0::CommMode expected_comm_mode) noexcept {
  // Check if mode pins are configured
  gpio_num_t spi_mode_gpio = spi.GetPinMapping(tmc51x0::TMC51x0CtrlPin::SPI_MODE);
  gpio_num_t sd_mode_gpio = spi.GetPinMapping(tmc51x0::TMC51x0CtrlPin::SD_MODE);
  
  constexpr gpio_num_t UNMAPPED_PIN = static_cast<gpio_num_t>(-1);
  
  // If pins are not configured, skip verification
  if (spi_mode_gpio == UNMAPPED_PIN || sd_mode_gpio == UNMAPPED_PIN) {
    ESP_LOGI(TAG, "Mode pins not configured, skipping verification");
    return true;
  }
  
  // Read mode pins
  auto mode_result = driver.io.GetOperatingMode();
  if (!mode_result) {
    ESP_LOGW(TAG, "⚠ Failed to read mode pins for verification (ErrorCode: %d)", static_cast<int>(mode_result.Error()));
    ESP_LOGW(TAG, "   Check: Mode pin connections and communication interface");
    return false;
  }
  tmc51x0::ChipCommMode actual_mode = mode_result.Value();
  
  // Verify mode matches expected communication interface
  bool mode_valid = false;
  const char* mode_name = nullptr;
  
  if (expected_comm_mode == tmc51x0::CommMode::SPI) {
    // For SPI, we expect SPI_MODE=HIGH
    // SD_MODE can be LOW (internal ramp) or HIGH (external step/dir)
    if (actual_mode == tmc51x0::ChipCommMode::SPI_INTERNAL_RAMP ||
        actual_mode == tmc51x0::ChipCommMode::SPI_EXTERNAL_STEPDIR) {
      mode_valid = true;
      mode_name = (actual_mode == tmc51x0::ChipCommMode::SPI_INTERNAL_RAMP) 
                  ? "SPI + Internal Ramp" 
                  : "SPI + External Step/Dir";
    }
  } else if (expected_comm_mode == tmc51x0::CommMode::UART) {
    // For UART, we expect SPI_MODE=LOW, SD_MODE=LOW
    if (actual_mode == tmc51x0::ChipCommMode::UART_INTERNAL_RAMP) {
      mode_valid = true;
      mode_name = "UART + Internal Ramp";
    }
  }
  
  // Note: STANDALONE_EXTERNAL_STEPDIR mode (SPI_MODE=LOW, SD_MODE=HIGH) is not used
  // with SPI or UART communication interfaces, so it's not checked here
  
  if (mode_valid) {
    ESP_LOGI(TAG, "✓ Mode pin verification passed: %s (matches %s interface)", 
             mode_name,
             (expected_comm_mode == tmc51x0::CommMode::SPI) ? "SPI" : "UART");
    return true;
  } else {
    ESP_LOGE(TAG, "✗ Mode pin verification FAILED: Mode pins indicate %d, but using %s interface",
             static_cast<int>(actual_mode),
             (expected_comm_mode == tmc51x0::CommMode::SPI) ? "SPI" : "UART");
    ESP_LOGE(TAG, "  Expected: SPI_MODE=%s, SD_MODE=%s for %s",
             (expected_comm_mode == tmc51x0::CommMode::SPI) ? "HIGH" : "LOW",
             (expected_comm_mode == tmc51x0::CommMode::SPI) ? "LOW/HIGH" : "LOW",
             (expected_comm_mode == tmc51x0::CommMode::SPI) ? "SPI" : "UART");
    return false;
  }
}

/**
 * @brief Create and initialize a test driver instance
 * 
 * This helper function creates a fully configured TMC51x0 driver instance
 * with the selected motor, board, and platform configuration.
 * 
 * @note Reference switches are configured but with stop_enable disabled
 *       unless explicitly testing that feature. This prevents the motor
 *       from stopping during normal tests.
 * 
 * @return Unique pointer to TestDriverHandle, or nullptr on failure
 */
std::unique_ptr<TestDriverHandle> create_test_driver(bool enable_ref_switch_stop = false) noexcept {
  auto handle = std::make_unique<TestDriverHandle>();
  
  // Get complete pin configuration from test config
  Esp32SpiPinConfig pin_config = tmc51x0_test_config::GetDefaultPinConfig();
  
  // Create SPI communication interface
  handle->spi = std::make_unique<Esp32SPI>(
    tmc51x0_test_config::SPI_HOST,
    pin_config,
    tmc51x0_test_config::SPI_CLOCK_SPEED_HZ);
  
  // Initialize SPI interface
  auto spi_init_result = handle->spi->Initialize();
  if (!spi_init_result) {
    ESP_LOGE(TAG, "❌ Failed to initialize SPI interface (ErrorCode: %d)", static_cast<int>(spi_init_result.Error()));
    ESP_LOGE(TAG, "   Check: SPI pin configuration, clock speed, and hardware connections");
    return nullptr;
  }
  ESP_LOGI(TAG, "✓ SPI interface initialized successfully");
  
  // Explicitly set chain length to 1 for single-chip mode
  handle->spi->SetDaisyChainLength(1);
  ESP_LOGI(TAG, "Configured for single-chip mode (chain length = 1)");
  
  // Create TMC51x0 driver instance
  handle->driver = std::make_unique<tmc51x0::TMC51x0<Esp32SPI>>(*handle->spi);
  
  // Verify mode pins match expected communication mode (if pins are configured)
  if (!verify_mode_pins(*handle->spi, *handle->driver, tmc51x0::CommMode::SPI)) {
    ESP_LOGE(TAG, "Mode pin verification failed - driver may not work correctly");
    // Continue anyway, but log the error
  }
  
  // Configure driver using helper functions
  tmc51x0::DriverConfig cfg{};
  
  // Configure driver from unified test rig selection
  tmc51x0_test_config::ConfigureDriverFromTestRig<SELECTED_TEST_RIG>(cfg);
  
  // Override with test-specific values if needed
  cfg.chopper.mres = TEST_MRES;
  
  // Initialize driver
  if (!handle->driver->Initialize(cfg)) {
    ESP_LOGE(TAG, "Failed to initialize TMC51x0 driver");
    return nullptr;
  }
  
  // Reference switches and encoder are now configured automatically during Initialize()
  // via DriverConfig. If we need to override stop enable for tests, do it after initialization.
  if (!enable_ref_switch_stop) {
    // Disable stop on reference switches for normal tests
    // This prevents the motor from stopping during tests
    cfg.reference_switch_config.left_switch_stop_enable = false;
    cfg.reference_switch_config.right_switch_stop_enable = false;
    // Re-configure with updated settings
    handle->driver->switches.ConfigureReferenceSwitch(cfg.reference_switch_config);
    ESP_LOGI(TAG, "Reference switches configured but stop disabled (normal test mode)");
  } else {
    ESP_LOGI(TAG, "Reference switches configured with stop enabled (testing switch feature)");
  }
  
  ESP_LOGI(TAG, "Driver initialized successfully");
  
  return handle;
}

//=============================================================================
// CORE TESTS
//=============================================================================

bool test_driver_initialization() noexcept {
  ESP_LOGI(TAG, "Testing driver initialization...");
  
  auto handle = create_test_driver();
  if (!handle) {
    ESP_LOGE(TAG, "Failed to create test driver");
    return false;
  }
  
  // Verify driver status
  tmc51x0::DriverStatus status = handle->driver->status.GetStatus();
  ESP_LOGI(TAG, "Driver Status: %d", static_cast<int>(status));
  ESP_LOGI(TAG, "✓ Driver initialized and ready");
  
  return true;
}

bool test_register_read_write() noexcept {
  ESP_LOGI(TAG, "Testing register read/write operations...");
  
  auto handle = create_test_driver();
  if (!handle) {
    ESP_LOGE(TAG, "Failed to create test driver");
    return false;
  }
  
  // Test reading global status (GSTAT register)
  bool drv_err = false, uv_cp = false;
  auto status_result = handle->driver->status.GetGlobalStatus(drv_err, uv_cp);
  if (!status_result) {
    ESP_LOGE(TAG, "❌ Failed to read global status (ErrorCode: %d)", static_cast<int>(status_result.Error()));
    ESP_LOGE(TAG, "   Check: SPI communication and chip power");
    return false;
  }
  bool reset = status_result.Value();
  ESP_LOGI(TAG, "✓ Global status read: reset=%d, drv_err=%d, uv_cp=%d", reset ? 1 : 0, drv_err ? 1 : 0, uv_cp ? 1 : 0);
  
  // Test writing X_COMPARE register in degrees (write-only per datasheet)
  constexpr float TEST_X_COMPARE_DEG = 22.2f; // ~12345 steps for 200 steps/rev motor
  if (!handle->driver->events.SetXCompare(TEST_X_COMPARE_DEG, tmc51x0::Unit::Deg)) {
    ESP_LOGE(TAG, "Failed to write X_COMPARE register");
    return false;
  }
  ESP_LOGI(TAG, "X_COMPARE register written: %.2f degrees (write-only register, verified via write response)", TEST_X_COMPARE_DEG);
  
  ESP_LOGI(TAG, "✓ Register read/write test passed");
  return true;
}

bool test_motor_parameter_settings() noexcept {
  ESP_LOGI(TAG, "Testing motor parameter settings...");
  
  auto handle = create_test_driver();
  if (!handle) {
    ESP_LOGE(TAG, "Failed to create test driver");
    return false;
  }
  
  // Verify chopper settings
  auto chopconf_result = handle->driver->motorControl.GetChopperConfig();
  if (!chopconf_result) {
    ESP_LOGE(TAG, "❌ Failed to read CHOPCONF register (ErrorCode: %d)", static_cast<int>(chopconf_result.Error()));
    ESP_LOGE(TAG, "   Check: SPI communication");
    return false;
  }
  tmc51x0::ChopperConfig chopconf_config = chopconf_result.Value();
  
  // Convert to register structure for bit access
  tmc51x0::CHOPCONF_Register chopconf{};
  // Note: We can't fully reconstruct the register from ChopperConfig, but we can check key fields
  ESP_LOGI(TAG, "CHOPCONF: toff=%u, mres=%u, intpol=%u", chopconf_config.toff, static_cast<uint8_t>(chopconf_config.mres), chopconf_config.intpol ? 1 : 0);
  
  if (chopconf_config.toff != TEST_TOFF) {
    ESP_LOGE(TAG, "TOFF mismatch: expected %u, got %u", TEST_TOFF, chopconf_config.toff);
    return false;
  }
  if (chopconf_config.mres != TEST_MRES) {
    ESP_LOGE(TAG, "MRES mismatch: expected %u, got %u", static_cast<uint8_t>(TEST_MRES), static_cast<uint8_t>(chopconf_config.mres));
    return false;
  }
  if (chopconf_config.intpol != Motor::INTERPOLATION) {
    ESP_LOGE(TAG, "INTPOL mismatch: expected %d, got %d", Motor::INTERPOLATION, chopconf_config.intpol ? 1 : 0);
    return false;
  }
  
  // Test setting new motor current values (using mA with proper conversion)
  constexpr uint16_t NEW_IRUN_MA = 1500; // Test with 1.5A
  constexpr uint16_t NEW_IHOLD_MA = 500; // Test with 0.5A
  
  uint8_t irun_reg = CalculateCurrentRegister(NEW_IRUN_MA);
  uint8_t ihold_reg = CalculateCurrentRegister(NEW_IHOLD_MA);
  
  if (!handle->driver->motorControl.SetCurrent(irun_reg, ihold_reg)) {
    ESP_LOGE(TAG, "Failed to set motor current");
    return false;
  }
  ESP_LOGI(TAG, "Updated IHOLD_IRUN: irun=%u (~%dmA), ihold=%u (~%dmA) (write-only register, verified via write response)", 
           irun_reg, NEW_IRUN_MA, ihold_reg, NEW_IHOLD_MA);
  
  ESP_LOGI(TAG, "✓ Motor parameter settings test passed");
  return true;
}

bool test_ramp_parameter_settings() noexcept {
  ESP_LOGI(TAG, "Testing ramp parameter settings...");
  
  auto handle = create_test_driver();
  if (!handle) {
    ESP_LOGE(TAG, "Failed to create test driver");
    return false;
  }
  
  // Set ramp parameters in physical units
  if (!handle->driver->rampControl.SetMaxSpeed(TEST_MAX_SPEED_RPM, tmc51x0::Unit::RPM)) {
    ESP_LOGE(TAG, "Failed to set max speed");
    return false;
  }
  if (!handle->driver->rampControl.SetAcceleration(TEST_ACCELERATION_REV_S2, tmc51x0::Unit::RevPerSec)) {
    ESP_LOGE(TAG, "Failed to set acceleration");
    return false;
  }
  if (!handle->driver->rampControl.SetDeceleration(TEST_DECELERATION_REV_S2, tmc51x0::Unit::RevPerSec)) {
    ESP_LOGE(TAG, "Failed to set deceleration");
    return false;
  }
  
  ESP_LOGI(TAG, "Ramp parameters set: VMAX=%.1f RPM, AMAX=%.1f rev/s², DMAX=%.1f rev/s² (write-only registers, verified via write response)",
           TEST_MAX_SPEED_RPM, TEST_ACCELERATION_REV_S2, TEST_DECELERATION_REV_S2);
  
  // Test setting target position in degrees
  constexpr float TEST_TARGET_DEG = 18.0f; // ~10000 steps for 200 steps/rev motor
  handle->driver->rampControl.SetTargetPosition(TEST_TARGET_DEG, tmc51x0::Unit::Deg);
  
  auto pos_result = handle->driver->rampControl.GetCurrentPosition(tmc51x0::Unit::Deg);
  if (!pos_result) {
    ESP_LOGE(TAG, "❌ Failed to get current position (ErrorCode: %d)", static_cast<int>(pos_result.Error()));
    return false;
  }
  float current_pos = pos_result.Value();
  ESP_LOGI(TAG, "✓ Target position set to %.2f degrees, current position: %.2f degrees", TEST_TARGET_DEG, current_pos);
  
  ESP_LOGI(TAG, "✓ Ramp parameter settings test passed");
  return true;
}

bool test_global_configuration() noexcept {
  ESP_LOGI(TAG, "Testing global configuration settings...");
  
  auto handle = create_test_driver();
  if (!handle) {
    ESP_LOGE(TAG, "Failed to create test driver");
    return false;
  }
  
  // Configure global settings
  tmc51x0::GlobalConfig gconf{};
  gconf.en_short_standstill_timeout = true;
  gconf.diag0.error = true;
  gconf.diag0.otpw = true;
  gconf.en_stealthchop_step_filter = true;
  handle->driver->motorControl.ConfigureGlobalConfig(gconf);
  
  // Read back and verify
  auto gconf_result = handle->driver->GetComm().ReadRegister(tmc51x0::Registers::GCONF, handle->driver->communication.GetDaisyChainPosition());
  if (!gconf_result) {
    ESP_LOGE(TAG, "❌ Failed to read GCONF register (ErrorCode: %d)", static_cast<int>(gconf_result.Error()));
    ESP_LOGE(TAG, "   Check: SPI communication");
    return false;
  }
  uint32_t gconf_value = gconf_result.Value();
  
  tmc51x0::GCONF_Register gconf_reg{};
  gconf_reg.value = gconf_value;
  ESP_LOGI(TAG, "GCONF: en_short_standstill_timeout=%u, diag0_error=%u, diag0_otpw=%u, en_stealthchop_step_filter=%u",
           gconf_reg.bits.faststandstill, gconf_reg.bits.diag0_error, gconf_reg.bits.diag0_otpw,
           gconf_reg.bits.multistep_filt);
  
  if (gconf_reg.bits.faststandstill != 1) {
    ESP_LOGE(TAG, "en_short_standstill_timeout not set correctly");
    return false;
  }
  if (gconf_reg.bits.diag0_error != 1) {
    ESP_LOGE(TAG, "diag0_error not set correctly");
    return false;
  }
  if (gconf_reg.bits.diag0_otpw != 1) {
    ESP_LOGE(TAG, "diag0_otpw not set correctly");
    return false;
  }
  if (gconf_reg.bits.multistep_filt != 1) {
    ESP_LOGE(TAG, "en_stealthchop_step_filter not set correctly");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Global configuration test passed");
  return true;
}

//=============================================================================
// MOTOR CONTROL TESTS
//=============================================================================

bool test_enable_disable() noexcept {
  ESP_LOGI(TAG, "Testing motor enable/disable...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Test enable
  auto enable_result = handle->driver->motorControl.Enable();
  if (!enable_result) {
    ESP_LOGE(TAG, "❌ Failed to enable motor (ErrorCode: %d)", static_cast<int>(enable_result.Error()));
    ESP_LOGE(TAG, "   Check: Enable pin connection and power supply");
    return false;
  }
  ESP_LOGI(TAG, "✓ Motor enabled successfully");
  
  vTaskDelay(pdMS_TO_TICKS(100));
  
  // Test disable
  auto disable_result = handle->driver->motorControl.Disable();
  if (!disable_result) {
    ESP_LOGE(TAG, "❌ Failed to disable motor (ErrorCode: %d)", static_cast<int>(disable_result.Error()));
    ESP_LOGE(TAG, "   Check: Enable pin connection");
    return false;
  }
  ESP_LOGI(TAG, "✓ Motor disabled");
  
  vTaskDelay(pdMS_TO_TICKS(100));
  
  // Re-enable for further tests
  handle->driver->motorControl.Enable();
  ESP_LOGI(TAG, "✓ Motor re-enabled");
  
  return true;
}

bool test_current_control() noexcept {
  ESP_LOGI(TAG, "Testing current control...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Test setting currents (converting mA to register values)
  constexpr uint16_t TARGET_RUN_MA = 1800;
  constexpr uint16_t TARGET_HOLD_MA = 900;
  
  uint8_t irun_val = CalculateCurrentRegister(TARGET_RUN_MA);
  uint8_t ihold_val = CalculateCurrentRegister(TARGET_HOLD_MA);
  
  if (!handle->driver->motorControl.SetCurrent(irun_val, ihold_val)) {
    ESP_LOGE(TAG, "Failed to set current");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Current control test passed (Run=%dmA [reg=%u], Hold=%dmA [reg=%u])",
           TARGET_RUN_MA, irun_val, TARGET_HOLD_MA, ihold_val);
  return true;
}

bool test_chopper_configuration() noexcept {
  ESP_LOGI(TAG, "Testing chopper configuration...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  tmc51x0::ChopperConfig chop_cfg{};
  chop_cfg.toff = Motor::TOFF;
  chop_cfg.hstrt = Motor::HSTRT;
  chop_cfg.hend = Motor::HEND;
  chop_cfg.tbl = Motor::TBL;
  chop_cfg.mres = TEST_MRES;
  chop_cfg.intpol = Motor::INTERPOLATION;
  chop_cfg.dedge = false;
  chop_cfg.mode = tmc51x0::ChopperMode::SPREAD_CYCLE;
  
  if (!handle->driver->motorControl.ConfigureChopper(chop_cfg)) {
    ESP_LOGE(TAG, "Failed to configure chopper");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Chopper configuration test passed (SpreadCycle mode)");
  return true;
}

bool test_stealthchop_configuration() noexcept {
  ESP_LOGI(TAG, "Testing StealthChop configuration and Automatic Tuning (AT)...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  tmc51x0::StealthChopConfig stealth_cfg{};
  stealth_cfg.pwm_autoscale = Motor::STEALTH_AUTOSCALE;
  stealth_cfg.pwm_autograd = Motor::STEALTH_AUTOGRAD;
  stealth_cfg.pwm_freq = Motor::STEALTH_FREQ;
  stealth_cfg.pwm_grad = 0;
  stealth_cfg.pwm_ofs = Motor::STEALTH_OFS;
  stealth_cfg.pwm_reg = 4;
  stealth_cfg.pwm_lim = 12;
  
  if (!handle->driver->motorControl.ConfigureStealthChop(stealth_cfg)) {
    ESP_LOGE(TAG, "Failed to configure StealthChop");
    return false;
  }

  // Demonstrate Automatic Tuning Sequence (Datasheet Section 7.1)
  // Step 1: AT#1 - Standstill at nominal current
  ESP_LOGI(TAG, "Demonstrating AT#1: Enabling driver and waiting in standstill...");
  
  // Ensure sufficient current for AT#1 (using motor config target currents)
  uint8_t at_irun = CalculateCurrentRegister(Motor::TARGET_RUN_CURRENT_MA);
  uint8_t at_ihold = CalculateCurrentRegister(Motor::TARGET_HOLD_CURRENT_MA);
  handle->driver->motorControl.SetCurrent(at_irun, at_ihold);
  
  if (!handle->driver->motorControl.Enable()) {
    ESP_LOGE(TAG, "Failed to enable motor for AT#1");
    return false;
  }
  
  // Wait > 130ms for AT#1 (Datasheet requires ~130ms)
  vTaskDelay(pdMS_TO_TICKS(200));
  ESP_LOGI(TAG, "AT#1 Wait Complete. Check PWM_OFS_AUTO if needed.");

  // Step 2: AT#2 - Move at medium velocity
  // Move at ~60-120 RPM output speed. 
  // 90 RPM output = 1.5 rev/s output = 1.5 * STEPS_PER_REV steps/s
  float at2_speed = 1.5f * STEPS_PER_REV;
  ESP_LOGI(TAG, "Demonstrating AT#2: Moving at medium velocity (%.2f steps/s)...", at2_speed);
  
  // Configure ramp for motion in physical units
  handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::VELOCITY_POS);
  // Convert at2_speed from steps/s to RPM (assuming 200 steps/rev motor)
  float at2_speed_rpm = (at2_speed / 200.0f) * 60.0f; // Convert steps/s to RPM
  handle->driver->rampControl.SetMaxSpeed(at2_speed_rpm, tmc51x0::Unit::RPM); 
  float at2_accel_rev_s2 = (at2_speed * 2.0f / 200.0f); // Convert steps/s² to rev/s²
  handle->driver->rampControl.SetAcceleration(at2_accel_rev_s2, tmc51x0::Unit::RevPerSec); // Reach speed in 0.5s

  // Let it run for a bit to allow AT#2 tuning (requires ~8 fullsteps per change of +/-1)
  vTaskDelay(pdMS_TO_TICKS(1500)); // 1.5 second run
  
  ESP_LOGI(TAG, "AT#2 Motion Complete.");

  // Read back auto-tuned values (optional check)
  uint8_t pwm_grad_auto = 0;
  auto pwm_result = handle->driver->status.GetPwmAuto(pwm_grad_auto);
  if (pwm_result) {
    uint8_t pwm_ofs_auto = pwm_result.Value();
    ESP_LOGI(TAG, "✓ Auto-Tuned Values: PWM_OFS_AUTO=%d, PWM_GRAD_AUTO=%d", pwm_ofs_auto, pwm_grad_auto);
  } else {
    ESP_LOGW(TAG, "⚠ Could not read auto-tuned values (ErrorCode: %d)", static_cast<int>(pwm_result.Error()));
  }

  // Stop and Disable
  handle->driver->rampControl.Stop();
  vTaskDelay(pdMS_TO_TICKS(500));
  handle->driver->motorControl.Disable();
  
  ESP_LOGI(TAG, "✓ StealthChop configuration and AT sequence test passed");
  return true;
}

bool test_mode_change_speeds() noexcept {
  ESP_LOGI(TAG, "Testing mode change speeds...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Use physical units for mode change speeds
  float low_rpm = 12.0f;  // 0.2 rev/s = 12 RPM
  float med_rpm = 30.0f; // 0.5 rev/s = 30 RPM
  float high_rpm = 60.0f; // 1.0 rev/s = 60 RPM

  if (!handle->driver->thresholds.SetModeChangeSpeeds(low_rpm, med_rpm, high_rpm, tmc51x0::Unit::RPM)) {
    ESP_LOGE(TAG, "Failed to set mode change speeds");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Mode change speeds test passed (low=%.1f RPM, med=%.1f RPM, high=%.1f RPM)", low_rpm, med_rpm, high_rpm);
  return true;
}

bool test_global_scaler() noexcept {
  ESP_LOGI(TAG, "Testing global scaler...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  if (!handle->driver->motorControl.SetGlobalScaler(64)) {
    ESP_LOGE(TAG, "Failed to set global scaler");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Global scaler test passed (set to 64)");
  return true;
}

bool test_freewheeling_mode() noexcept {
  ESP_LOGI(TAG, "Testing freewheeling mode...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  bool success = true;
  
  // Test setting freewheeling mode through ConfigureStealthChop
  tmc51x0::StealthChopConfig stealth_config{};
  stealth_config.freewheel = tmc51x0::PWMFreewheel::NORMAL;
  stealth_config.pwm_autoscale = Motor::STEALTH_AUTOSCALE; // Maintain required settings
  stealth_config.pwm_autograd = Motor::STEALTH_AUTOGRAD;
  stealth_config.pwm_freq = Motor::STEALTH_FREQ;
  stealth_config.pwm_ofs = Motor::STEALTH_OFS;

  if (!handle->driver->motorControl.ConfigureStealthChop(stealth_config)) {
    ESP_LOGE(TAG, "Failed to set freewheeling to NORMAL");
    success = false;
  }
  
  stealth_config.freewheel = tmc51x0::PWMFreewheel::ENABLED;
  if (!handle->driver->motorControl.ConfigureStealthChop(stealth_config)) {
    ESP_LOGE(TAG, "Failed to set freewheeling to ENABLED");
    success = false;
  }
  
  if (success) {
    ESP_LOGI(TAG, "✓ Freewheeling mode test passed");
  }
  
  return success;
}

bool test_coolstep_configuration() noexcept {
  ESP_LOGI(TAG, "Testing CoolStep configuration...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Configure CoolStep with user-friendly API
  tmc51x0::CoolStepConfig cool_cfg{};
  
  // Set thresholds using actual SG values (more intuitive than raw 0-15)
  cool_cfg.lower_threshold_sg = 64;   // SEMIN*32 = 2*32 (when SG < 64, increase current)
  cool_cfg.upper_threshold_sg = 256;  // (SEMIN+SEMAX+1)*32 = (2+5+1)*32 (when SG >= 256, decrease current)
  
  // Configure step sizes using enums
  cool_cfg.increment_step = tmc51x0::CoolStepIncrementStep::STEP_2;  // Moderate response speed
  cool_cfg.decrement_speed = tmc51x0::CoolStepDecrementSpeed::EVERY_8;  // Stable reduction
  
  // Minimum current: 50% of IRUN
  cool_cfg.min_current = tmc51x0::CoolStepMinCurrent::HALF_IRUN;
  
  // Disable filter for high time resolution
  cool_cfg.enable_filter = false;
  
  // Set velocity thresholds in RPM (CoolStep only active between these speeds)
  cool_cfg.min_velocity = 15.0f;   // Enable CoolStep above 15 RPM (~500 steps/s for 200 steps/rev)
  cool_cfg.max_velocity = 150.0f;   // Disable CoolStep above 150 RPM (~5000 steps/s for 200 steps/rev)
  cool_cfg.velocity_unit = tmc51x0::Unit::RPM;
  
  if (!handle->driver->motorControl.ConfigureCoolStep(cool_cfg)) {
    ESP_LOGE(TAG, "Failed to configure CoolStep");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ CoolStep configuration test passed");
  return true;
}

bool test_dcstep_configuration() noexcept {
  ESP_LOGI(TAG, "Testing DCStep configuration...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Configure DcStep with user-friendly API
  tmc51x0::DcStepConfig dc_cfg{};
  
  // Set minimum velocity threshold in RPM
  dc_cfg.min_velocity = 30.0f;   // Enable DcStep above 30 RPM (~1000 steps/s for 200 steps/rev)
  dc_cfg.velocity_unit = tmc51x0::Unit::RPM;
  
  // Auto-calculate PWM on-time from blank time (recommended)
  dc_cfg.pwm_on_time_us = 0.0f;  // 0 = auto-calculate
  
  // Moderate stall detection sensitivity (recommended)
  dc_cfg.stall_sensitivity = tmc51x0::DcStepStallSensitivity::MODERATE;
  
  // Don't stop on stall (continue operation)
  dc_cfg.stop_on_stall = false;
  
  if (!handle->driver->motorControl.ConfigureDcStep(dc_cfg)) {
    ESP_LOGE(TAG, "Failed to configure DCStep");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ DCStep configuration test passed");
  return true;
}

bool test_microstep_lookup_table() noexcept {
  ESP_LOGI(TAG, "Testing microstep lookup table...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  bool success = true;
  
  if (!handle->driver->motorControl.SetMicrostepLookupTable(0, 0x00000000)) {
    ESP_LOGE(TAG, "Failed to set LUT entry");
    success = false;
  }
  
  if (!handle->driver->motorControl.SetMicrostepLookupTableSegmentation(0, 1, 2, 3, 64, 128, 192)) {
    ESP_LOGE(TAG, "Failed to set LUT segmentation");
    success = false;
  }
  
  if (!handle->driver->motorControl.SetMicrostepLookupTableStart(128)) {
    ESP_LOGE(TAG, "Failed to set LUT start");
    success = false;
  }
  
  if (success) {
    ESP_LOGI(TAG, "✓ Microstep lookup table test passed");
  }
  
  return success;
}

bool test_motor_setup_from_spec() noexcept {
  ESP_LOGI(TAG, "Testing motor setup from specifications...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  tmc51x0::MotorSpec motor_spec{};
  motor_spec.steps_per_rev = Motor::MOTOR_FULL_STEPS;
  motor_spec.rated_current_ma = Motor::RATED_CURRENT_MA;
  
  // Note: SetupMotorFromSpec may use approximation, so we use a warning-level test
  auto result = handle->driver->motorControl.SetupMotorFromSpec(motor_spec);
  if (result.IsErr()) {
    ESP_LOGW(TAG, "Motor setup from spec may have used approximation");
  }
  
  ESP_LOGI(TAG, "✓ Motor setup from spec test passed (may use approximation)");
  return true; // Always return true as this may use approximation
}

//=============================================================================
// RAMP CONTROL TESTS
//=============================================================================

bool test_ramp_modes() noexcept {
  ESP_LOGI(TAG, "Testing ramp modes...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  bool success = true;
  
  // Test POSITIONING mode
  if (!handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::POSITIONING)) {
    ESP_LOGE(TAG, "Failed to set POSITIONING mode");
    success = false;
  } else {
    ESP_LOGI(TAG, "✓ POSITIONING mode set");
  }
  
  // Test VELOCITY_POS mode
  if (!handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::VELOCITY_POS)) {
    ESP_LOGE(TAG, "Failed to set VELOCITY_POS mode");
    success = false;
  } else {
    ESP_LOGI(TAG, "✓ VELOCITY_POS mode set");
  }
  
  // Test VELOCITY_NEG mode
  if (!handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::VELOCITY_NEG)) {
    ESP_LOGE(TAG, "Failed to set VELOCITY_NEG mode");
    success = false;
  } else {
    ESP_LOGI(TAG, "✓ VELOCITY_NEG mode set");
  }
  
  // Test HOLD mode
  if (!handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::HOLD)) {
    ESP_LOGE(TAG, "Failed to set HOLD mode");
    success = false;
  } else {
    ESP_LOGI(TAG, "✓ HOLD mode set");
  }
  
  // Return to POSITIONING mode
  handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::POSITIONING);
  
  if (success) {
    ESP_LOGI(TAG, "✓ Ramp modes test passed");
  }
  
  return success;
}

bool test_position_control() noexcept {
  ESP_LOGI(TAG, "Testing position control...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::POSITIONING);
  
  // Test setting target position in degrees
  if (!handle->driver->rampControl.SetTargetPosition(1.8f, tmc51x0::Unit::Deg)) { // ~1000 steps for 200 steps/rev
    ESP_LOGE(TAG, "Failed to set target position");
    return false;
  }
  
  // Test getting current position in degrees
  auto current_result = handle->driver->rampControl.GetCurrentPosition(tmc51x0::Unit::Deg);
  if (!current_result) {
    ESP_LOGE(TAG, "❌ Failed to get current position (ErrorCode: %d)", static_cast<int>(current_result.Error()));
    return false;
  }
  float current = current_result.Value();
  ESP_LOGI(TAG, "✓ Current position: %.2f degrees", current);
  
  // Test setting current position in degrees
  auto set_pos_result = handle->driver->rampControl.SetCurrentPosition(0.0f, tmc51x0::Unit::Deg);
  if (!set_pos_result) {
    ESP_LOGE(TAG, "❌ Failed to set current position (ErrorCode: %d)", static_cast<int>(set_pos_result.Error()));
    return false;
  }
  auto verify_pos_result = handle->driver->rampControl.GetCurrentPosition(tmc51x0::Unit::Deg);
  if (!verify_pos_result) {
    ESP_LOGE(TAG, "❌ Failed to get current position after set (ErrorCode: %d)", static_cast<int>(verify_pos_result.Error()));
    return false;
  }
  current = verify_pos_result.Value();
  if (current != 0.0f) {
    ESP_LOGW(TAG, "SetCurrentPosition may not have taken effect immediately");
  }
  
  ESP_LOGI(TAG, "✓ Position control test passed");
  return true;
}

bool test_speed_control() noexcept {
  ESP_LOGI(TAG, "Testing speed control...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  bool success = true;
  
  // Test setting max speed in RPM (appropriate for NEMA 44mm 2A motor)
  // Use 2 revolutions per second (output shaft) = 120 RPM
  float max_speed_rpm = 120.0f;
  if (!handle->driver->rampControl.SetMaxSpeed(max_speed_rpm, tmc51x0::Unit::RPM)) {
    ESP_LOGE(TAG, "Failed to set max speed");
    success = false;
  }
  
  // Test setting acceleration in rev/s² (appropriate for NEMA 44mm 2A motor)
  // Reach max speed in 0.5s = 240 rev/s²
  float accel_rev_s2 = 240.0f;
  if (!handle->driver->rampControl.SetAcceleration(accel_rev_s2, tmc51x0::Unit::RevPerSec)) {
    ESP_LOGE(TAG, "Failed to set acceleration");
    success = false;
  }
  
  // Test setting accelerations (both) - higher decel for faster stopping
  if (!handle->driver->rampControl.SetAcceleration(accel_rev_s2, tmc51x0::Unit::RevPerSec)) {
    ESP_LOGE(TAG, "Failed to set acceleration");
    success = false;
  }
  if (!handle->driver->rampControl.SetDeceleration(accel_rev_s2 * 1.5f, tmc51x0::Unit::RevPerSec)) {
    ESP_LOGE(TAG, "Failed to set deceleration");
    success = false;
  }
  
  // Test getting current speed in RPM
  auto speed_result = handle->driver->rampControl.GetCurrentSpeed(tmc51x0::Unit::RPM);
  if (!speed_result) {
    ESP_LOGE(TAG, "❌ Failed to get current speed (ErrorCode: %d)", static_cast<int>(speed_result.Error()));
    return false;
  }
  float speed_rpm = speed_result.Value();
  ESP_LOGI(TAG, "Current speed: %.2f RPM", speed_rpm);
  
  if (success) {
    ESP_LOGI(TAG, "✓ Speed control test passed");
  }
  
  return success;
}

bool test_ramp_parameters() noexcept {
  ESP_LOGI(TAG, "Testing ramp parameters...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  bool success = true;
  
  // Use physical units for ramp speeds
  float vstart_rpm = 0.6f; // 0.01 rev/s = 0.6 RPM
  float vstop_rpm = 0.3f; // 0.005 rev/s = 0.3 RPM
  
  // Test ramp speeds in RPM
  if (!handle->driver->rampControl.SetRampSpeeds(vstart_rpm, vstop_rpm, 0.0f, tmc51x0::Unit::RPM)) {
    ESP_LOGE(TAG, "Failed to set ramp speeds");
    success = false;
  }
  
  // Test power-down delay
  if (!handle->driver->rampControl.SetPowerDownDelay(100)) {
    ESP_LOGE(TAG, "Failed to set power-down delay");
    success = false;
  }
  
  // Test zero wait time
  if (!handle->driver->rampControl.SetZeroWaitTime(50)) {
    ESP_LOGE(TAG, "Failed to set zero wait time");
    success = false;
  }
  
  // Test first acceleration in rev/s²
  float first_accel_rev_s2 = (vstart_rpm / 60.0f) * 5.0f; // Convert RPM to rev/s, then multiply by 5
  if (!handle->driver->rampControl.SetFirstAcceleration(first_accel_rev_s2, tmc51x0::Unit::RevPerSec)) {
    ESP_LOGE(TAG, "Failed to set first acceleration");
    success = false;
  }
  
  if (success) {
    ESP_LOGI(TAG, "✓ Ramp parameters test passed");
  }
  
  return success;
}

bool test_reference_switch_configuration() noexcept {
  ESP_LOGI(TAG, "Testing reference switch configuration and homing...");
  
  // Create driver with reference switch stop enabled (this is the test for that feature)
  auto handle = create_test_driver(true); // enable_ref_switch_stop = true
  if (!handle) {
    return false;
  }
  
  // Get reference switch configuration from platform config
  tmc51x0::ReferenceSwitchConfig ref_cfg = 
      tmc51x0_test_config::GetTestRigReferenceSwitchConfig<SELECTED_TEST_RIG>();
  
  if (!handle->driver->switches.ConfigureReferenceSwitch(ref_cfg)) {
    ESP_LOGE(TAG, "Failed to configure reference switch");
    return false;
  }

  // Test Switch Homing (Simulation / API check)
  // Since we don't have physical switches in this test, we just verify the API call works
  // and timeouts (as expected without a switch press).
  ESP_LOGI(TAG, "Testing PerformSwitchHoming API (expect timeout)...");
  int32_t final_pos = 0;
  // Use short timeout for test
  tmc51x0::TMC51x0<Esp32SPI>::Homing::BoundsOptions opt{};
  opt.speed_unit = tmc51x0::Unit::RPM;
  opt.position_unit = tmc51x0::Unit::Deg;
  opt.search_speed = Test::Motion::BOUNDS_SEARCH_SPEED_RPM;
  opt.search_span = 360.0F;     // cap the move so we don't run forever during long timeouts
  opt.backoff_distance = 0.0F;  // no backoff in this API check
  opt.timeout_ms = 100;

  auto result = handle->driver->homing.PerformSwitchHoming(true, opt, final_pos, true);
  
  if (result.IsErr()) {
    ESP_LOGI(TAG, "Homing timed out as expected (no physical switch)");
  } else {
    ESP_LOGW(TAG, "Homing reported success unexpectedly (switch noise?)");
  }
  
  ESP_LOGI(TAG, "✓ Reference switch configuration test passed");
  return true;
}

bool test_unit_conversions() noexcept {
  ESP_LOGI(TAG, "Testing unit conversions...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  handle->driver->rampControl.SetRampMode(tmc51x0::RampMode::POSITIONING);
  
  bool success = true;
  
  // Test setting target position in millimeters
  if (!handle->driver->rampControl.SetTargetPosition(10.0F, tmc51x0::Unit::Mm)) {
    ESP_LOGE(TAG, "Failed to set target position in mm");
    success = false;
  }
  
  // Test setting max speed in RPM
  if (!handle->driver->rampControl.SetMaxSpeed(60.0F, tmc51x0::Unit::RPM)) {
    ESP_LOGE(TAG, "Failed to set max speed in RPM");
    success = false;
  }
  
  // Test unit conversion functions
  float target_mm = 10.0F;
  int32_t steps = tmc51x0::MmToSteps(target_mm, STEPS_PER_REV, LEAD_SCREW_PITCH_MM);
  ESP_LOGI(TAG, "%.2f mm = %ld steps", target_mm, steps);
  
  float target_rpm = 100.0F;
  float steps_per_sec = tmc51x0::RpmToStepsPerSec(target_rpm, STEPS_PER_REV);
  ESP_LOGI(TAG, "%.2f RPM = %.2f steps/s", target_rpm, steps_per_sec);
  
  if (success) {
    ESP_LOGI(TAG, "✓ Unit conversions test passed");
  }
  
  return success;
}

//=============================================================================
// DIAGNOSTICS TESTS
//=============================================================================

bool test_driver_status() noexcept {
  ESP_LOGI(TAG, "Testing driver status...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  tmc51x0::DriverStatus status = handle->driver->status.GetStatus();
  ESP_LOGI(TAG, "Driver Status: %d", static_cast<int>(status));
  
  ESP_LOGI(TAG, "✓ Driver status test passed");
  return true;
}

bool test_stallguard() noexcept {
  ESP_LOGI(TAG, "Testing StallGuard2...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Use default test configuration for StallGuard
  tmc51x0::StallGuardConfig sg_cfg{};
  sg_cfg.threshold = Test::StallGuard::SGT_HOMING;
  sg_cfg.enable_filter = Test::StallGuard::FILTER_ENABLED;
  // Note: semin/semax are CoolStep parameters, not StallGuard2 parameters
  
  if (!handle->driver->stallGuard.ConfigureStallGuard(sg_cfg)) {
    ESP_LOGE(TAG, "Failed to configure StallGuard");
    return false;
  }
  
  auto sg_result = handle->driver->stallGuard.GetStallGuard();
  if (!sg_result) {
    ESP_LOGE(TAG, "❌ Failed to get StallGuard value (ErrorCode: %d)", static_cast<int>(sg_result.Error()));
    ESP_LOGE(TAG, "   Check: SPI communication and StallGuard configuration");
    return false;
  }
  uint16_t sg_value = sg_result.Value();
  ESP_LOGI(TAG, "✓ StallGuard Value: %u (threshold=%d)", sg_value, sg_cfg.threshold);
  
  ESP_LOGI(TAG, "✓ StallGuard2 test passed");
  return true;
}

bool test_lost_steps() noexcept {
  ESP_LOGI(TAG, "Testing lost steps detection...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  auto lost_steps_result = handle->driver->status.GetLostSteps();
  if (lost_steps_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get lost steps (ErrorCode: %d)", static_cast<int>(lost_steps_result.Error()));
    return false;
  }
  uint32_t lost_steps = lost_steps_result.Value();
  ESP_LOGI(TAG, "Lost Steps: %lu", lost_steps);
  
  ESP_LOGI(TAG, "✓ Lost steps detection test passed");
  return true;
}

bool test_phase_currents() noexcept {
  ESP_LOGI(TAG, "Testing phase currents...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  int16_t phase_b = 0;
  auto phase_a_result = handle->driver->status.GetMicrostepCurrent(phase_b);
  if (phase_a_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get microstep currents (ErrorCode: %d)", static_cast<int>(phase_a_result.Error()));
    return false;
  }
  int16_t phase_a = phase_a_result.Value();
  
  ESP_LOGI(TAG, "Phase A: %d, Phase B: %d", phase_a, phase_b);
  
  ESP_LOGI(TAG, "✓ Phase currents test passed");
  return true;
}

bool test_pwm_scale() noexcept {
  ESP_LOGI(TAG, "Testing PWM scale...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  int16_t pwm_scale_auto = 0;
  auto pwm_scale_result = handle->driver->status.GetPwmScale(pwm_scale_auto);
  if (pwm_scale_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get PWM scale (ErrorCode: %d)", static_cast<int>(pwm_scale_result.Error()));
    return false;
  }
  uint8_t pwm_scale_sum = pwm_scale_result.Value();
  
  ESP_LOGI(TAG, "PWM Scale Sum: %u, Auto: %d", pwm_scale_sum, pwm_scale_auto);
  
  ESP_LOGI(TAG, "✓ PWM scale test passed");
  return true;
}

bool test_microstep_diagnostics() noexcept {
  ESP_LOGI(TAG, "Testing microstep diagnostics...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  auto time_between_result = handle->driver->status.GetTimeBetweenMicrosteps();
  if (time_between_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get time between microsteps (ErrorCode: %d)", static_cast<int>(time_between_result.Error()));
    return false;
  }
  uint32_t time_between = time_between_result.Value();
  ESP_LOGI(TAG, "Time Between Microsteps: %lu", time_between);
  
  auto mscnt_result = handle->driver->status.GetMicrostepCounter();
  if (mscnt_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get microstep counter (ErrorCode: %d)", static_cast<int>(mscnt_result.Error()));
    return false;
  }
  uint16_t mscnt = mscnt_result.Value();
  ESP_LOGI(TAG, "Microstep Counter: %u", mscnt);
  
  int16_t ms_current_b = 0;
  auto ms_current_a_result = handle->driver->status.GetMicrostepCurrent(ms_current_b);
  if (ms_current_a_result.IsOk()) {
    int16_t ms_current_a = ms_current_a_result.Value();
    ESP_LOGI(TAG, "Microstep Current A: %d, B: %d", ms_current_a, ms_current_b);
  }
  
  ESP_LOGI(TAG, "✓ Microstep diagnostics test passed");
  return true;
}

bool test_gpio_pins() noexcept {
  ESP_LOGI(TAG, "Testing GPIO pins...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  auto gpio_pins_result = handle->driver->io.ReadGpioPins();
  if (gpio_pins_result.IsErr()) {
    ESP_LOGW(TAG, "Failed to read GPIO pins (may not be mapped) (ErrorCode: %d)", static_cast<int>(gpio_pins_result.Error()));
    return true; // Not a failure if pins aren't mapped
  }
  uint32_t gpio_pins = gpio_pins_result.Value();
  
  ESP_LOGI(TAG, "GPIO Pins: 0x%08lX", gpio_pins);
  
  ESP_LOGI(TAG, "✓ GPIO pins test passed");
  return true;
}

bool test_factory_otp_config() noexcept {
  ESP_LOGI(TAG, "Testing factory and OTP configuration...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  auto factory_cfg_result = handle->driver->status.ReadFactoryConfig();
  if (factory_cfg_result.IsErr()) {
    ESP_LOGW(TAG, "Failed to read factory config (ErrorCode: %d)", static_cast<int>(factory_cfg_result.Error()));
  } else {
    uint8_t factory_cfg = factory_cfg_result.Value();
    (void)factory_cfg; // Suppress unused warning if not used
  }
  
  bool otp_s2_level = false, otp_bbm = false, otp_tbl = false;
  auto otp_result = handle->driver->status.ReadOtpConfig(otp_s2_level, otp_bbm, otp_tbl);
  uint8_t otp_fclktrim = 0;
  if (otp_result.IsErr()) {
    ESP_LOGW(TAG, "Failed to read OTP config (ErrorCode: %d)", static_cast<int>(otp_result.Error()));
  } else {
    otp_fclktrim = otp_result.Value();
  }
  
  ESP_LOGI(TAG, "OTP: FCLKTRIM=%u, S2=%s, BBM=%s, TBL=%s", 
           otp_fclktrim, otp_s2_level ? "true" : "false",
           otp_bbm ? "true" : "false", otp_tbl ? "true" : "false");
  
  ESP_LOGI(TAG, "✓ Factory/OTP configuration test passed");
  return true;
}

bool test_uart_transmission_count() noexcept {
  ESP_LOGI(TAG, "Testing UART transmission count...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  auto uart_count_result = handle->driver->status.GetUartTransmissionCount();
  uint8_t uart_count = uart_count_result.IsOk() ? uart_count_result.Value() : 0;
  ESP_LOGI(TAG, "UART Transmission Count: %u", uart_count);
  
  ESP_LOGI(TAG, "✓ UART transmission count test passed");
  return true;
}

bool test_offset_calibration() noexcept {
  ESP_LOGI(TAG, "Testing offset calibration...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  uint8_t offset_b = 0;
  auto offset_a_result = handle->driver->status.ReadOffsetCalibration(offset_b);
  uint8_t offset_a = 0;
  if (offset_a_result.IsErr()) {
    ESP_LOGW(TAG, "Failed to read offset calibration (ErrorCode: %d)", static_cast<int>(offset_a_result.Error()));
  } else {
    offset_a = offset_a_result.Value();
  }
  
  ESP_LOGI(TAG, "Offset A: %u, Offset B: %u", offset_a, offset_b);
  
  ESP_LOGI(TAG, "✓ Offset calibration test passed");
  return true;
}

bool test_sensorless_homing() noexcept {
  ESP_LOGI(TAG, "Testing sensorless homing...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Configure StallGuard2 for homing using default test config
  tmc51x0::StallGuardConfig sg_config{};
  sg_config.threshold = Test::StallGuard::SGT_HOMING;
  sg_config.enable_filter = Test::StallGuard::FILTER_ENABLED;
  // Note: semin/semax are CoolStep parameters, not StallGuard2 parameters
  
  if (!handle->driver->stallGuard.ConfigureStallGuard(sg_config)) {
    ESP_LOGE(TAG, "Failed to configure StallGuard2 for homing");
    return false;
  }
  
  // Note: PerformSensorlessHoming requires motor movement and may not complete
  // in a test environment, so we just verify the configuration
  ESP_LOGI(TAG, "StallGuard2 configured for sensorless homing (threshold=%d)", sg_config.threshold);
  
  ESP_LOGI(TAG, "✓ Sensorless homing test passed");
  return true;
}

bool test_open_load() noexcept {
  ESP_LOGI(TAG, "Testing open load detection...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Ensure SpreadCycle mode (StealthChop disabled) for open load detection
  auto gconf_result = handle->driver->motorControl.GetGlobalConfig();
  if (gconf_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get global config (ErrorCode: %d)", static_cast<int>(gconf_result.Error()));
    return false;
  }
  tmc51x0::GlobalConfig gconf = gconf_result.Value();
  
  if (gconf.en_stealthchop_mode) {
    ESP_LOGI(TAG, "Disabling StealthChop for open load detection test");
    gconf.en_stealthchop_mode = false;
    if (!handle->driver->motorControl.ConfigureGlobalConfig(gconf)) {
      ESP_LOGE(TAG, "Failed to disable StealthChop");
      return false;
    }
    vTaskDelay(pdMS_TO_TICKS(100));
  }
  
  // Move motor at low velocity in physical units
  ESP_LOGI(TAG, "Moving motor for open load detection test");
  handle->driver->rampControl.SetMaxSpeed(15.0f, tmc51x0::Unit::RPM); // ~500 steps/s for 200 steps/rev
  handle->driver->rampControl.SetTargetPosition(1.8f, tmc51x0::Unit::Deg);  // ~1024 steps (4× microstep resolution) for 200 steps/rev
  
  // Check for open load during motion
  bool open_load_detected = false;
  uint32_t check_count = 0;
    auto target_reached_result = handle->driver->rampControl.IsTargetReached();
    bool target_reached = target_reached_result.IsOk() ? target_reached_result.Value() : false;
    while (!target_reached && check_count < 50) {
      target_reached_result = handle->driver->rampControl.IsTargetReached();
      target_reached = target_reached_result.IsOk() ? target_reached_result.Value() : false;
    auto phase_a_result = handle->driver->status.IsOpenLoadA();
    auto phase_b_result = handle->driver->status.IsOpenLoadB();
    bool phase_a = phase_a_result.IsOk() ? phase_a_result.Value() : false;
    bool phase_b = phase_b_result.IsOk() ? phase_b_result.Value() : false;
    
    if (phase_a || phase_b) {
      ESP_LOGW(TAG, "Open load detected: Phase A=%d, Phase B=%d", phase_a, phase_b);
      open_load_detected = true;
    }
    
    check_count++;
    vTaskDelay(pdMS_TO_TICKS(20));
  }
  
  // Wait for motion to complete
  while (!handle->driver->rampControl.IsTargetReached()) {
    vTaskDelay(pdMS_TO_TICKS(10));
  }
  
  // Check both phases at once
  bool phase_a_final, phase_b_final;
  if (handle->driver->status.CheckOpenLoad(phase_a_final, phase_b_final)) {
    ESP_LOGI(TAG, "Final open load check: Phase A=%d, Phase B=%d", 
             phase_a_final, phase_b_final);
    if (phase_a_final || phase_b_final) {
      ESP_LOGW(TAG, "⚠️ Open load flags are set (check wiring if unexpected)");
      ESP_LOGW(TAG, "Note: Flags may also indicate undervoltage, high velocity, or other conditions");
    } else {
      ESP_LOGI(TAG, "✓ No open load detected");
    }
  } else {
    ESP_LOGE(TAG, "Failed to check open load status");
    return false;
  }
  
  if (!open_load_detected && !phase_a_final && !phase_b_final) {
    ESP_LOGI(TAG, "✓ Open load detection test passed (no open load detected)");
  }
  
  return true;
}

//=============================================================================
// PROTECTION TESTS
//=============================================================================

bool test_short_circuit_protection() noexcept {
  ESP_LOGI(TAG, "Testing short circuit protection...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  tmc51x0::PowerStageParameters power_cfg{};
  power_cfg.s2vs_voltage_mv = 625;  // 625mV = S2VS_LEVEL=6 (recommended)
  power_cfg.s2g_voltage_mv = 625;  // 625mV = S2G_LEVEL=6 (recommended)
  power_cfg.shortfilter = 1;
  power_cfg.short_detection_delay_us_x10 = 0;  // Auto (0.85µs = shortdelay=0)
  
  if (!handle->driver->powerStage.ConfigureShortProtection(power_cfg)) {
    ESP_LOGE(TAG, "Failed to configure short protection");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Short circuit protection test passed");
  return true;
}

bool test_overtemperature_protection() noexcept {
  ESP_LOGI(TAG, "Testing overtemperature protection...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Overtemperature status is read via diagnostics.GetStatus()
  tmc51x0::DriverStatus prot_status = handle->driver->status.GetStatus();
  bool has_otpw = (prot_status == tmc51x0::DriverStatus::OTPW);
  bool has_ot = (prot_status == tmc51x0::DriverStatus::OT);
  ESP_LOGI(TAG, "OTPW: %s, OT: %s", has_otpw ? "true" : "false", has_ot ? "true" : "false");
  
  ESP_LOGI(TAG, "✓ Overtemperature protection test passed");
  return true;
}

//=============================================================================
// ENCODER TESTS
//=============================================================================

bool test_encoder_configuration() noexcept {
  ESP_LOGI(TAG, "Testing encoder configuration...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Get encoder configuration from platform config
  tmc51x0::EncoderConfig enc_cfg = 
      tmc51x0_test_config::GetTestRigEncoderConfig<SELECTED_TEST_RIG>();
  
  // A/B polarity requirements (set explicitly for this test)
  enc_cfg.require_a_high = false;
  enc_cfg.require_b_high = false;
  enc_cfg.ignore_ab_polarity = true;  // Ignore A/B polarity
  
  // Clear/latch mode (set explicitly for this test)
  enc_cfg.clear_enc_x_on_event = false;
  enc_cfg.latch_xactual_with_enc = false;
  
  if (!handle->driver->encoder.Configure(enc_cfg)) {
    ESP_LOGE(TAG, "Failed to configure encoder");
    return false;
  }
  
  // Verify configuration by reading it back
  auto read_cfg_result = handle->driver->encoder.GetEncoderConfig();
  if (read_cfg_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to read encoder configuration (ErrorCode: %d)", static_cast<int>(read_cfg_result.Error()));
    return false;
  }
  tmc51x0::EncoderConfig read_cfg = read_cfg_result.Value();
  
  ESP_LOGI(TAG, "✓ Encoder configuration verified");
  return true;
}

bool test_encoder_resolution() noexcept {
  ESP_LOGI(TAG, "Testing encoder resolution...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Note: SetResolution may use approximation, so we use a warning-level test
  // Use platform config encoder resolution
  auto result = handle->driver->encoder.SetResolution(
    Motor::MOTOR_FULL_STEPS, // Use Motor namespace constant 
    tmc51x0_test_config::GetTestRigEncoderPulsesPerRev<SELECTED_TEST_RIG>(), 
    tmc51x0_test_config::GetTestRigEncoderInvertDirection<SELECTED_TEST_RIG>());
  
  if (result.IsErr()) {
    ESP_LOGW(TAG, "Encoder resolution set with approximation");
  }
  
  ESP_LOGI(TAG, "✓ Encoder resolution test passed");
  return true;
}

bool test_encoder_position_reading() noexcept {
  ESP_LOGI(TAG, "Testing encoder position reading...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  auto enc_pos_result = handle->driver->encoder.GetPosition();
  if (enc_pos_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get encoder position (ErrorCode: %d)", static_cast<int>(enc_pos_result.Error()));
    return false;
  }
  int32_t enc_pos = enc_pos_result.Value();
  ESP_LOGI(TAG, "Encoder position: %ld", enc_pos);
  
  ESP_LOGI(TAG, "✓ Encoder position reading test passed");
  return true;
}

bool test_deviation_detection() noexcept {
  ESP_LOGI(TAG, "Testing deviation detection...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  // Set allowed deviation
  auto set_dev_result = handle->driver->encoder.SetAllowedDeviation(10);
  if (set_dev_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to set allowed deviation (ErrorCode: %d)", static_cast<int>(set_dev_result.Error()));
    return false;
  }
  
  // Check for deviation
  auto deviation_result = handle->driver->encoder.IsDeviationWarning();
  if (deviation_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to check deviation (ErrorCode: %d)", static_cast<int>(deviation_result.Error()));
    return false;
  }
  bool dev_detected = deviation_result.Value();
  ESP_LOGI(TAG, "Deviation Warning: %s", dev_detected ? "true" : "false");
  
  // Clear deviation warning
  if (!handle->driver->encoder.ClearDeviationWarning()) {
    ESP_LOGE(TAG, "Failed to clear deviation warning");
    return false;
  }
  
  ESP_LOGI(TAG, "✓ Deviation detection test passed");
  return true;
}

bool test_latched_position() noexcept {
  ESP_LOGI(TAG, "Testing latched position...");
  
  auto handle = create_test_driver();
  if (!handle) {
    return false;
  }
  
  int32_t latched = 0;
  auto latched_result = handle->driver->encoder.GetLatchedPosition();
  if (latched_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get latched position (ErrorCode: %d)", static_cast<int>(latched_result.Error()));
    return false;
  }
  latched = latched_result.Value();
  if (latched_result.IsErr()) {
    ESP_LOGE(TAG, "Failed to get latched position");
    return false;
  }
  ESP_LOGI(TAG, "Latched position: %ld", latched);
  
  ESP_LOGI(TAG, "✓ Latched position test passed");
  return true;
}

//=============================================================================
// MAIN FUNCTION
//=============================================================================

extern "C" void app_main(void) {
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║         ESP32 TMC51x0 INTERNAL RAMP COMPREHENSIVE TEST SUITE                  ║");
  ESP_LOGI(TAG, "║                         HardFOC TMC51x0 Driver Tests                           ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  ESP_LOGI(TAG, "Driver version: %s", tmc51x0::GetDriverVersion());
  
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "Configuration:");
  ESP_LOGI(TAG, "  Motor: 17HS4401S-PG518 (gearbox)");
  ESP_LOGI(TAG, "  Board: TMC51x0 Evaluation Kit");
  ESP_LOGI(TAG, "  Platform: Test Rig (with AS5047U encoder and reference switches)");
  ESP_LOGI(TAG, "  Communication Mode: SPI Internal Ramp (SPI_MODE=HIGH, SD_MODE=LOW)");
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "Note: Reference switches are configured but do NOT stop the motor");
  ESP_LOGI(TAG, "      unless directly testing that feature (test_reference_switch_configuration).");
  ESP_LOGI(TAG, "");
  
  vTaskDelay(pdMS_TO_TICKS(1000));
  
  // Report test section configuration
  print_test_section_status(TAG, "Internal Ramp Comprehensive");
  
  //=============================================================================
  // CORE TESTS
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                              CORE TESTS                                        ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_INITIALIZATION_TESTS, "INITIALIZATION TESTS", 5,
    ESP_LOGI(TAG, "Running initialization tests...");
    RUN_TEST_IN_TASK("driver_initialization", test_driver_initialization, 8192, 1);
    flip_test_progress_indicator();
  );

  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_REGISTER_ACCESS_TESTS, "REGISTER ACCESS TESTS", 5,
    ESP_LOGI(TAG, "Running register access tests...");
    RUN_TEST_IN_TASK("register_read_write", test_register_read_write, 8192, 1);
    flip_test_progress_indicator();
  );

  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_MOTOR_PARAMETER_TESTS, "MOTOR PARAMETER TESTS", 5,
    ESP_LOGI(TAG, "Running motor parameter tests...");
    RUN_TEST_IN_TASK("motor_parameter_settings", test_motor_parameter_settings, 8192, 1);
    flip_test_progress_indicator();
  );

  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_RAMP_PARAMETER_TESTS, "RAMP PARAMETER TESTS", 5,
    ESP_LOGI(TAG, "Running ramp parameter tests...");
    RUN_TEST_IN_TASK("ramp_parameter_settings", test_ramp_parameter_settings, 8192, 1);
    flip_test_progress_indicator();
  );

  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_GLOBAL_CONFIG_TESTS, "GLOBAL CONFIGURATION TESTS", 5,
    ESP_LOGI(TAG, "Running global configuration tests...");
    RUN_TEST_IN_TASK("global_configuration", test_global_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  //=============================================================================
  // MOTOR CONTROL TESTS
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                          MOTOR CONTROL TESTS                                   ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_ENABLE_DISABLE_TESTS, "ENABLE/DISABLE TESTS", 5,
    ESP_LOGI(TAG, "Running enable/disable tests...");
    RUN_TEST_IN_TASK("enable_disable", test_enable_disable, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_CURRENT_CONTROL_TESTS, "CURRENT CONTROL TESTS", 5,
    ESP_LOGI(TAG, "Running current control tests...");
    RUN_TEST_IN_TASK("current_control", test_current_control, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_CHOPPER_TESTS, "CHOPPER TESTS", 5,
    ESP_LOGI(TAG, "Running chopper tests...");
    RUN_TEST_IN_TASK("chopper_configuration", test_chopper_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_STEALTHCHOP_TESTS, "STEALTHCHOP TESTS", 5,
    ESP_LOGI(TAG, "Running StealthChop tests...");
    RUN_TEST_IN_TASK("stealthchop_configuration", test_stealthchop_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_MODE_CHANGE_SPEED_TESTS, "MODE CHANGE SPEED TESTS", 5,
    ESP_LOGI(TAG, "Running mode change speed tests...");
    RUN_TEST_IN_TASK("mode_change_speeds", test_mode_change_speeds, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_GLOBAL_SCALER_TESTS, "GLOBAL SCALER TESTS", 5,
    ESP_LOGI(TAG, "Running global scaler tests...");
    RUN_TEST_IN_TASK("global_scaler", test_global_scaler, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_FREEWHEELING_TESTS, "FREEWHEELING TESTS", 5,
    ESP_LOGI(TAG, "Running freewheeling tests...");
    RUN_TEST_IN_TASK("freewheeling_mode", test_freewheeling_mode, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_COOLSTEP_TESTS, "COOLSTEP TESTS", 5,
    ESP_LOGI(TAG, "Running CoolStep tests...");
    RUN_TEST_IN_TASK("coolstep_configuration", test_coolstep_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_DCSTEP_TESTS, "DCSTEP TESTS", 5,
    ESP_LOGI(TAG, "Running DCStep tests...");
    RUN_TEST_IN_TASK("dcstep_configuration", test_dcstep_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_LUT_TESTS, "MICROSTEP LUT TESTS", 5,
    ESP_LOGI(TAG, "Running microstep LUT tests...");
    RUN_TEST_IN_TASK("microstep_lookup_table", test_microstep_lookup_table, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_MOTOR_SETUP_TESTS, "MOTOR SETUP TESTS", 5,
    ESP_LOGI(TAG, "Running motor setup tests...");
    RUN_TEST_IN_TASK("motor_setup_from_spec", test_motor_setup_from_spec, 8192, 1);
    flip_test_progress_indicator();
  );
  
  //=============================================================================
  // RAMP CONTROL TESTS
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                          RAMP CONTROL TESTS                                    ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_RAMP_MODE_TESTS, "RAMP MODE TESTS", 5,
    ESP_LOGI(TAG, "Running ramp mode tests...");
    RUN_TEST_IN_TASK("ramp_modes", test_ramp_modes, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_POSITION_CONTROL_TESTS, "POSITION CONTROL TESTS", 5,
    ESP_LOGI(TAG, "Running position control tests...");
    RUN_TEST_IN_TASK("position_control", test_position_control, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_SPEED_CONTROL_TESTS, "SPEED CONTROL TESTS", 5,
    ESP_LOGI(TAG, "Running speed control tests...");
    RUN_TEST_IN_TASK("speed_control", test_speed_control, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_RAMP_PARAMETER_TESTS_RAMP, "RAMP PARAMETER TESTS", 5,
    ESP_LOGI(TAG, "Running ramp parameter tests...");
    RUN_TEST_IN_TASK("ramp_parameters", test_ramp_parameters, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_REFERENCE_SWITCH_TESTS, "REFERENCE SWITCH TESTS", 5,
    ESP_LOGI(TAG, "Running reference switch tests...");
    RUN_TEST_IN_TASK("reference_switch", test_reference_switch_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_UNIT_CONVERSION_TESTS, "UNIT CONVERSION TESTS", 5,
    ESP_LOGI(TAG, "Running unit conversion tests...");
    RUN_TEST_IN_TASK("unit_conversions", test_unit_conversions, 8192, 1);
    flip_test_progress_indicator();
  );
  
  //=============================================================================
  // DIAGNOSTICS TESTS
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                          DIAGNOSTICS TESTS                                    ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_DRIVER_STATUS_TESTS, "DRIVER STATUS TESTS", 5,
    ESP_LOGI(TAG, "Running driver status tests...");
    RUN_TEST_IN_TASK("driver_status", test_driver_status, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_STALLGUARD_TESTS, "STALLGUARD TESTS", 5,
    ESP_LOGI(TAG, "Running StallGuard tests...");
    RUN_TEST_IN_TASK("stallguard", test_stallguard, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_LOST_STEPS_TESTS, "LOST STEPS TESTS", 5,
    ESP_LOGI(TAG, "Running lost steps tests...");
    RUN_TEST_IN_TASK("lost_steps", test_lost_steps, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_PHASE_CURRENT_TESTS, "PHASE CURRENT TESTS", 5,
    ESP_LOGI(TAG, "Running phase current tests...");
    RUN_TEST_IN_TASK("phase_currents", test_phase_currents, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_PWM_SCALE_TESTS, "PWM SCALE TESTS", 5,
    ESP_LOGI(TAG, "Running PWM scale tests...");
    RUN_TEST_IN_TASK("pwm_scale", test_pwm_scale, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_MICROSTEP_DIAGNOSTICS_TESTS, "MICROSTEP DIAGNOSTICS TESTS", 5,
    ESP_LOGI(TAG, "Running microstep diagnostics tests...");
    RUN_TEST_IN_TASK("microstep_diagnostics", test_microstep_diagnostics, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_GPIO_TESTS, "GPIO TESTS", 5,
    ESP_LOGI(TAG, "Running GPIO tests...");
    RUN_TEST_IN_TASK("gpio_pins", test_gpio_pins, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_FACTORY_OTP_TESTS, "FACTORY/OTP TESTS", 5,
    ESP_LOGI(TAG, "Running factory/OTP tests...");
    RUN_TEST_IN_TASK("factory_otp_config", test_factory_otp_config, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_UART_COUNT_TESTS, "UART COUNT TESTS", 5,
    ESP_LOGI(TAG, "Running UART count tests...");
    RUN_TEST_IN_TASK("uart_transmission_count", test_uart_transmission_count, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_OFFSET_CALIBRATION_TESTS, "OFFSET CALIBRATION TESTS", 5,
    ESP_LOGI(TAG, "Running offset calibration tests...");
    RUN_TEST_IN_TASK("offset_calibration", test_offset_calibration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_SENSORLESS_HOMING_TESTS, "SENSORLESS HOMING TESTS", 5,
    ESP_LOGI(TAG, "Running sensorless homing tests...");
    RUN_TEST_IN_TASK("sensorless_homing", test_sensorless_homing, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_OPEN_LOAD_TESTS, "OPEN LOAD DETECTION TESTS", 5,
    ESP_LOGI(TAG, "Running open load detection tests...");
    RUN_TEST_IN_TASK("open_load", test_open_load, 8192, 1);
    flip_test_progress_indicator();
  );
  
  //=============================================================================
  // PROTECTION TESTS
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                          PROTECTION TESTS                                    ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_SHORT_CIRCUIT_TESTS, "SHORT CIRCUIT PROTECTION TESTS", 5,
    ESP_LOGI(TAG, "Running short circuit protection tests...");
    RUN_TEST_IN_TASK("short_circuit_protection", test_short_circuit_protection, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_OVERTEMPERATURE_TESTS, "OVERTEMPERATURE PROTECTION TESTS", 5,
    ESP_LOGI(TAG, "Running overtemperature protection tests...");
    RUN_TEST_IN_TASK("overtemperature_protection", test_overtemperature_protection, 8192, 1);
    flip_test_progress_indicator();
  );
  
  //=============================================================================
  // ENCODER TESTS
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                          ENCODER TESTS                                         ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_ENCODER_CONFIG_TESTS, "ENCODER CONFIGURATION TESTS", 5,
    ESP_LOGI(TAG, "Running encoder configuration tests...");
    RUN_TEST_IN_TASK("encoder_configuration", test_encoder_configuration, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_ENCODER_RESOLUTION_TESTS, "ENCODER RESOLUTION TESTS", 5,
    ESP_LOGI(TAG, "Running encoder resolution tests...");
    RUN_TEST_IN_TASK("encoder_resolution", test_encoder_resolution, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_ENCODER_POSITION_TESTS, "ENCODER POSITION TESTS", 5,
    ESP_LOGI(TAG, "Running encoder position tests...");
    RUN_TEST_IN_TASK("encoder_position_reading", test_encoder_position_reading, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_DEVIATION_DETECTION_TESTS, "DEVIATION DETECTION TESTS", 5,
    ESP_LOGI(TAG, "Running deviation detection tests...");
    RUN_TEST_IN_TASK("deviation_detection", test_deviation_detection, 8192, 1);
    flip_test_progress_indicator();
  );
  
  RUN_TEST_SECTION_IF_ENABLED_WITH_PATTERN(
    ENABLE_LATCHED_POSITION_TESTS, "LATCHED POSITION TESTS", 5,
    ESP_LOGI(TAG, "Running latched position tests...");
    RUN_TEST_IN_TASK("latched_position", test_latched_position, 8192, 1);
    flip_test_progress_indicator();
  );
  
  //=============================================================================
  // TEST SUMMARY
  //=============================================================================
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                          TEST SUMMARY                                         ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  
  print_test_summary(g_test_results, "Internal Ramp Comprehensive", TAG);
  
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "╔══════════════════════════════════════════════════════════════════════════════╗");
  ESP_LOGI(TAG, "║                    FEATURE COMPATIBILITY NOTES                                 ║");
  ESP_LOGI(TAG, "╚══════════════════════════════════════════════════════════════════════════════╝");
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "Features that can be used together:");
  ESP_LOGI(TAG, "  • StealthChop + CoolStep: Compatible, CoolStep adjusts current based on StallGuard");
  ESP_LOGI(TAG, "  • StealthChop + DCStep: Compatible, DCStep activates at higher speeds");
  ESP_LOGI(TAG, "  • SpreadCycle + CoolStep: Compatible, standard combination");
  ESP_LOGI(TAG, "  • SpreadCycle + DCStep: Compatible, DCStep for high-speed operation");
  ESP_LOGI(TAG, "  • StallGuard2 + Sensorless Homing: Compatible, StallGuard2 enables sensorless homing");
  ESP_LOGI(TAG, "  • Reference Switches + Encoder: Compatible, both can be used for position feedback");
  ESP_LOGI(TAG, "  • Microstep LUT + Interpolation: Compatible, LUT customizes microstep waveform");
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "Features that are mutually exclusive:");
  ESP_LOGI(TAG, "  • StealthChop vs SpreadCycle: Only one chopper mode active at a time");
  ESP_LOGI(TAG, "  • CoolStep vs DCStep: Both adjust current, but for different speed ranges");
  ESP_LOGI(TAG, "    (Can be configured with non-overlapping velocity thresholds)");
  ESP_LOGI(TAG, "");
  ESP_LOGI(TAG, "Feature interactions:");
  ESP_LOGI(TAG, "  • Mode Change Speeds: Control transitions between StealthChop and SpreadCycle");
  ESP_LOGI(TAG, "  • Global Scaler: Affects all current-based features (CoolStep, DCStep, etc.)");
  ESP_LOGI(TAG, "  • Freewheeling: Only active in StealthChop mode");
  ESP_LOGI(TAG, "  • Open Load Detection: Requires SpreadCycle mode (StealthChop disabled)");
  ESP_LOGI(TAG, "");
  
  while (true) {
    vTaskDelay(pdMS_TO_TICKS(10000));
  }
}