validation.h

Go to the documentation of this file.

// src/fl/channels/validation.h
//
// Validation test logic - stateless single-test execution
// Extracted from examples/validation for unit testing
 
#pragma once
 
#include "fl/stl/vector.h"
#include "fl/stl/string.h"
#include "fl/stl/optional.h"
#include "fl/stl/int.h"
#include "fl/stl/noexcept.h"
#include "fl/channels/rx/types.h"
 
// Forward declarations for detail modules
namespace fl {
namespace validation {
    class RxTest;  // IWYU pragma: keep
    class ResultFormatter;  // IWYU pragma: keep
    class Platform;  // IWYU pragma: keep
}
}
 
namespace fl {
 
namespace validation {

inline bool useRmtInternalLoopback(bool is_rmt_driver, int tx_pin,
                                   int rx_pin) FL_NO_EXCEPT {
    return is_rmt_driver && tx_pin == rx_pin;
}

inline RxBackend resolveCaptureBackend(RxBackend requested_backend,
                                       bool has_explicit_override,
                                       bool is_parlio_driver,
                                       bool is_esp32_c6) FL_NO_EXCEPT {
    if (!has_explicit_override && is_parlio_driver && is_esp32_c6) {
        return RxBackend::PARLIO_RX;
    }
    return requested_backend;
}

inline size_t captureEdgeCapacity(size_t shared_buffer_bytes,
                                  size_t expected_data_bytes,
                                  RxBackend backend) FL_NO_EXCEPT {
    constexpr size_t kEdgesPerByte = 16;
    constexpr size_t kFramingEdges = 2;
    const size_t max_size = static_cast<size_t>(-1);
 
    if (backend != RxBackend::ISR) {
        if (shared_buffer_bytes > max_size / 8) {
            return 0;
        }
        return shared_buffer_bytes * 8;
    }
 
    if (expected_data_bytes > (max_size - kFramingEdges) / kEdgesPerByte) {
        return 0;
    }
    const size_t required =
        expected_data_bytes * kEdgesPerByte + kFramingEdges;
    size_t capacity = 1;
    while (capacity < required) {
        if (capacity > max_size / 2) {
            return 0;
        }
        capacity *= 2;
    }
    return capacity;
}

inline bool isWholeCaptureFrame(size_t run_count, bool lead_run_is_low,
                                u32 lead_run_ns, u32 idle_threshold_ns,
                                size_t min_frame_runs) FL_NO_EXCEPT {
    constexpr size_t kLeadPlusOneByteRuns = 1 + 8 + 7;
    if (run_count >= min_frame_runs) {
        return true;
    }
    return run_count >= kLeadPlusOneByteRuns && lead_run_is_low &&
           lead_run_ns > idle_threshold_ns;
}

inline size_t rpPioMaxWireBytes(size_t edge_capacity,
                                size_t dma_tail_words,
                                u32 samples_per_dma_word,
                                u32 sample_period_ns,
                                u32 idle_tail_ns,
                                u32 arming_lead_in_ns,
                                u32 bit_period_ns) FL_NO_EXCEPT {
    constexpr size_t kPhasesPerByte = 16;  // 8 bits x (high + low)
    constexpr u64 kBitsPerByte = 8;
 
    if (bit_period_ns == 0 || edge_capacity == 0 || samples_per_dma_word == 0 ||
        sample_period_ns == 0) {
        return 0;
    }
 
    const size_t by_pool = edge_capacity / kPhasesPerByte;
 
    const u64 dma_words =
        static_cast<u64>((edge_capacity + 1u) / 2u) + dma_tail_words;
    const u64 budget_ns =
        dma_words * samples_per_dma_word * sample_period_ns;
    const u64 reserved_ns =
        static_cast<u64>(idle_tail_ns) + arming_lead_in_ns;
    if (budget_ns <= reserved_ns) {
        return 0;
    }
    const u64 by_clock =
        (budget_ns - reserved_ns) / (kBitsPerByte * bit_period_ns);
 
    if (static_cast<u64>(by_pool) < by_clock) {
        return by_pool;
    }
    return static_cast<size_t>(by_clock);
}
 
}  // namespace validation

struct SingleTestConfig {
    string driver_name;           
    vector<int> lane_sizes;       
    string pattern;               
    int iterations;               
    int pin_tx;                   
    int pin_rx;                   
 
    SingleTestConfig() FL_NO_EXCEPT
        : pattern("MSB_LSB_A")
        , iterations(1)
        , pin_tx(1)
        , pin_rx(0) {}
};

struct SingleTestResult {
    bool success;                 
    bool passed;                  
    int total_tests;              
    int passed_tests;             
    u32 duration_ms;              
    string driver;                
    int lane_count;               
    vector<int> lane_sizes;       
    string pattern;               
 
    // Optional failure info
    optional<string> error_message;       
    optional<string> failure_pattern;     
    optional<string> failure_details;     
 
    SingleTestResult() FL_NO_EXCEPT
        : success(false)
        , passed(false)
        , total_tests(0)
        , passed_tests(0)
        , duration_ms(0)
        , lane_count(0) {}
};

struct DriverTestResult {
    fl::string driver_name;  
    int total_tests;         
    int passed_tests;        
    bool skipped;            
 
    DriverTestResult(const char* name)
        FL_NO_EXCEPT : driver_name(name)
        , total_tests(0)
        , passed_tests(0)
        , skipped(false) {}
 
    DriverTestResult() FL_NO_EXCEPT
        : total_tests(0)
        , passed_tests(0)
        , skipped(false) {}

    bool allPassed() const FL_NO_EXCEPT { return !skipped && total_tests > 0 && passed_tests == total_tests; }

    bool anyFailed() const FL_NO_EXCEPT { return !skipped && total_tests > 0 && passed_tests < total_tests; }
};

SingleTestResult runSingleValidationTest(const SingleTestConfig& config) FL_NO_EXCEPT;
 
}  // namespace fl