sim_utils.h

Go to the documentation of this file.

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <hal_posix/posix_utils.h>
#include <satcat5/cfgbus_core.h>
#include <satcat5/cfgbus_interrupt.h>
#include <satcat5/ethernet.h>
#include <satcat5/interrupts.h>
#include <satcat5/ip_stack.h>
#include <satcat5/log.h>
#include <satcat5/polling.h>
#include <satcat5/ptp_source.h>
#include <satcat5/timeref.h>
#include <string>
 
// Enable CBOR features?
#if SATCAT5_CBOR_ENABLE
#include <qcbor/qcbor_decode.h>
#endif
 
#define SATCAT5_MAKE_STRING(x) (std::string(x, x + sizeof(x)))
 
#define SATCAT5_TEST_START \
    CHECK(satcat5::irq::pre_test_reset()); \
    CHECK(satcat5::log::pre_test_reset()); \
    CHECK(satcat5::poll::pre_test_reset()); \
    CHECK(satcat5::test::pre_test_reset()); \
    satcat5::log::ToConsole log;
 
namespace satcat5 {
    namespace test {
        bool pre_test_reset();
 
        u8  rand_u8();
        u32 rand_u32();
        u64 rand_u64();
 
        std::string sim_filename(const char* pre, const char* ext);
 
        bool write(satcat5::io::Writeable* dst,
            unsigned nbytes, const u8* data);
        bool write(satcat5::io::Writeable* dst,
            const std::string& dat);
 
        bool read(satcat5::io::Readable* src,
            unsigned nbytes, const u8* data);
        bool read(satcat5::io::Readable* src,
            const std::string& ref);
        bool read(satcat5::io::ArrayRead src,
            const std::string& ref);
 
        void write_random_bytes(satcat5::io::Writeable* dst, unsigned nbytes);
        bool write_random_final(satcat5::io::Writeable* dst, unsigned nbytes);
 
        bool read_equal(
            satcat5::io::Readable* src1,
            satcat5::io::Readable* src2);
 
        class CborParser {
        public:
            explicit CborParser(satcat5::io::Readable* src, bool verbose=false);
 
            #if SATCAT5_CBOR_ENABLE
            QCBORItem get(const char* key) const;
            QCBORItem get(u32 key) const;
            #endif
 
        protected:
            u8 m_dat[2048];
            unsigned m_len;
        };
 
        class CountHelper {
        public:
            unsigned count() const {return m_count;}
            void count_reset() {m_count = 0;}
        protected:
            CountHelper() : m_count(0) {}
            ~CountHelper() {}
            unsigned m_count;
        };
 
        class CountAlways final
            : public CountHelper, public satcat5::poll::Always {
        public:
            CountAlways() {}
            void poll_always() override {++m_count;}
        };
 
        class CountArpResponse final
            : public CountHelper, public satcat5::eth::ArpListener {
        public:
            explicit CountArpResponse(satcat5::ip::Dispatch* iface)
                : m_arp(iface->arp()) {m_arp->add(this);}
            virtual ~CountArpResponse() {m_arp->remove(this);}
        protected:
            void arp_event(const satcat5::eth::MacAddr& mac, const satcat5::ip::Addr& ip) override {++m_count;}
            void gateway_change(const satcat5::ip::Addr& dstaddr, const satcat5::ip::Addr& gateway) override {}
            satcat5::eth::ProtoArp* const m_arp;
        };
 
        class CountOnDemand final
            : public CountHelper, public satcat5::poll::OnDemand {
        public:
            CountOnDemand() {}
        protected:
            void poll_demand() override {++m_count;}
        };
 
        class CountPingResponse final
            : public CountHelper, public satcat5::ip::PingListener {
        public:
            explicit CountPingResponse(satcat5::ip::Dispatch* iface)
                : m_icmp(iface->icmp()) {m_icmp->add(this);}
            virtual ~CountPingResponse() {m_icmp->remove(this);}
        protected:
            void ping_event(const satcat5::ip::Addr& from, u32 elapsed_usec) {++m_count;}
            satcat5::ip::ProtoIcmp* const m_icmp;
        };
 
        class CountPtpCallback final
            : public CountHelper, public satcat5::ptp::Callback {
        public:
            CountPtpCallback(satcat5::ptp::Source* src) : Callback(src) {}
            void ptp_ready(const satcat5::ptp::Measurement& data) override {++m_count;}
        };
 
        class CountTimer final
            : public CountHelper, public satcat5::poll::Timer {
        public:
            CountTimer() {}
            void timer_event() override {++m_count;}
        };
 
        class DebugAddress : public satcat5::net::Address {
            satcat5::io::PacketBufferHeap m_rx;
 
            // Implement the minimum required API.
            satcat5::net::Dispatch* iface() const override
                { return 0; }
            satcat5::io::Writeable* open_write(unsigned len) override
                { m_rx.write_abort(); return &m_rx; }
            void close() override
                { m_rx.write_finalize(); }
            bool ready() const
                { return true; }
        };
 
        class FastPosixTimer : public satcat5::util::TimeRef {
        public:
            FastPosixTimer() : satcat5::util::TimeRef(1000000) {}
            u32 raw() override { return m_timer.raw() << 8; }
        protected:
            satcat5::util::PosixTimer m_timer;
        };
 
        class IoEventCounter final
            : public CountHelper, public satcat5::io::EventListener {
        public:
            IoEventCounter() {}
        protected:
            void data_rcvd(satcat5::io::Readable* src) {++m_count;}
        };
 
        class LogProtocol : public satcat5::eth::Protocol {
        public:
            LogProtocol(
                satcat5::eth::Dispatch* dispatch,
                const satcat5::eth::MacType& ethertype);
            // Required API from eth::Protocol.
            void frame_rcvd(satcat5::io::LimitedRead& src) override;
        };
 
        class MockConfigBusMmap : public satcat5::cfg::ConfigBusMmap {
        public:
            MockConfigBusMmap();
            void clear_all(u32 val = 0);
            void clear_dev(unsigned devaddr, u32 val = 0);
            void irq_event();
 
        protected:
            u32 m_regs[satcat5::cfg::MAX_TOTAL_REGS];
        };
 
        class MockInterrupt : public CountHelper, public satcat5::cfg::Interrupt {
        public:
            explicit MockInterrupt(satcat5::cfg::ConfigBus* cfg);
 
            MockInterrupt(satcat5::cfg::ConfigBus* cfg, unsigned regaddr);
 
            void fire();
 
        protected:
            void irq_event() override {++m_count;}
 
            satcat5::cfg::ConfigBus* const m_cfg;
            unsigned m_regaddr;
        };
 
        class RandomSource
            : public satcat5::util::HeapAllocator
            , public satcat5::io::ArrayRead {
        public:
            explicit RandomSource(unsigned len);
            satcat5::io::Readable* read();
            inline unsigned len() const {return m_len;}
            inline void notify() {read_notify();}
            inline const u8* raw() const {return m_buffptr;}
        protected:
            const unsigned m_len;
        };
 
        class Statistics {
        public:
            Statistics();           
            void add(double x);     
            double mean() const;    
            double msq() const;     
            double rms() const;     
            double std() const;     
            double var() const;     
            double min() const;     
            double max() const;     
        protected:
            unsigned m_count;       
            double m_sum;           
            double m_sumsq;         
            double m_min;           
            double m_max;           
        };
 
        class TimerSimulation : public satcat5::util::TimeRef {
        public:
            // Implement the TimeRef API.
            TimerSimulation();
            ~TimerSimulation();
            u32 raw() override;
 
            void sim_step();
            void sim_wait(unsigned dly_msec);
 
        protected:
            u32 m_tref, m_tnow;
        };
    }
}