Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "electronic_throttle.h"
       4             : #include "dc_motor.h"
       5             : #include "table_helper.h"
       6             : #include "pwm_generator_logic.h"
       7             : #include "airmass.h"
       8             : #include "injector_model.h"
       9             : #include "stepper.h"
      10             : #include "tunerstudio_io.h"
      11             : #include "idle_thread.h"
      12             : #include "global_execution_queue.h"
      13             : 
      14             : #include "gmock/gmock.h"
      15             : 
      16             : class MockEtb : public IEtbController {
      17             : public:
      18             :         MockEtb();
      19             :         virtual ~MockEtb();
      20             : 
      21             :         // IEtbController mocks
      22           0 :         MOCK_METHOD(void, reset, (), (override));
      23          10 :         MOCK_METHOD(bool, isEtbMode, (), (override));
      24           0 :         MOCK_METHOD(void, update, (), (override));
      25          19 :         MOCK_METHOD(bool, init, (dc_function_e function, DcMotor* motor, pid_s* pidParameters, const ValueProvider3D* pedalMap, bool initializeThrottles), (override));
      26           4 :         MOCK_METHOD(void, setIdlePosition, (percent_t pos), (override));
      27           2 :         MOCK_METHOD(void, setWastegatePosition, (percent_t pos), (override));
      28           0 :         MOCK_METHOD(void, autoCalibrateTps, (), (override));
      29           0 :         MOCK_METHOD(const pid_state_s&, getPidState, (), (const, override));
      30           0 :         MOCK_METHOD(void, setLuaAdjustment, (percent_t adjustment), (override));
      31             : 
      32             : 
      33             :         // ClosedLoopController mocks
      34           0 :         MOCK_METHOD(expected<percent_t>, getSetpoint, (), (override));
      35           0 :         MOCK_METHOD(expected<percent_t>, observePlant, (), (override));
      36           0 :         MOCK_METHOD(expected<percent_t>, getOpenLoop, (percent_t setpoint), (override));
      37           0 :         MOCK_METHOD(expected<percent_t>, getClosedLoop, (percent_t setpoint, percent_t observation), (override));
      38           0 :         MOCK_METHOD(void, setOutput, (expected<percent_t> outputValue), (override));
      39             : };
      40             : 
      41             : class MockMotor : public DcMotor {
      42             : public:
      43             :         MockMotor();
      44             :         virtual ~MockMotor();
      45             : 
      46           8 :         MOCK_METHOD(bool, set, (float duty), (override));
      47           0 :         MOCK_METHOD(float, get, (), (const, override));
      48           8 :         MOCK_METHOD(void, enable, (), (override));
      49           6 :         MOCK_METHOD(void, disable, (const char *msg), (override));
      50           0 :         MOCK_METHOD(bool, isOpenDirection, (), (const, override));
      51             : };
      52             : 
      53             : class MockVp3d : public ValueProvider3D {
      54             : public:
      55             :         MockVp3d();
      56             :         virtual ~MockVp3d();
      57             : 
      58          72 :         MOCK_METHOD(float, getValue, (float xColumn, float yRow), (const, override));
      59             : };
      60             : 
      61             : class MockPwm : public IPwm {
      62             : public:
      63             :         MockPwm();
      64             :         virtual ~MockPwm();
      65             : 
      66          34 :         MOCK_METHOD(void, setSimplePwmDutyCycle, (float dutyCycle), (override));
      67             : };
      68             : 
      69             : class MockOutputPin : public OutputPin {
      70             : public:
      71             :         MockOutputPin();
      72             :         virtual ~MockOutputPin();
      73             : 
      74          37 :         MOCK_METHOD(void, setValue, (int value, bool isForce), (override));
      75             : };
      76             : 
      77             : class MockExecutor : public TestExecutor {
      78             : public:
      79             :         MockExecutor();
      80             :         virtual ~MockExecutor();
      81             : 
      82           0 :         MOCK_METHOD(void, scheduleByTimestamp, (const char *msg, scheduling_s *scheduling, efitimeus_t timeUs, action_s action), (override));
      83          24 :         MOCK_METHOD(void, scheduleByTimestampNt, (const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action), (override));
      84           0 :         MOCK_METHOD(void, scheduleForLater, (const char *msg, scheduling_s *scheduling, int delayUs, action_s action), (override));
      85           3 :         MOCK_METHOD(void, cancel, (scheduling_s*), (override));
      86             : };
      87             : 
      88             : class MockAirmass : public AirmassVeModelBase {
      89             : public:
      90             :         MockAirmass();
      91             :         virtual ~MockAirmass();
      92             : 
      93             :         MockVp3d veTable;
      94             : 
      95         247 :         MOCK_METHOD(AirmassResult, getAirmass, (int rpm, bool postState), (override));
      96             : };
      97             : 
      98             : class MockInjectorModel2 : public IInjectorModel {
      99             : public:
     100             :         MockInjectorModel2();
     101             :         virtual ~MockInjectorModel2();
     102             : 
     103           1 :         MOCK_METHOD(void, prepare, (), (override));
     104          66 :         MOCK_METHOD(floatms_t, getInjectionDuration, (float fuelMassGram), (const, override));
     105           1 :         MOCK_METHOD(float, getFuelMassForDuration, (floatms_t duration), (const, override));
     106           0 :         MOCK_METHOD(floatms_t, getDeadtime, (), (const, override));
     107             : };
     108             : 
     109             : class MockStepperHardware : public StepperHw {
     110             : public:
     111             :         MockStepperHardware();
     112             :         virtual ~MockStepperHardware();
     113             : 
     114           0 :         MOCK_METHOD(bool, step, (bool positive), (override));
     115             : };
     116             : 
     117             : class MockTsChannel : public TsChannelBase {
     118             : public:
     119             :         MockTsChannel();
     120             :         virtual ~MockTsChannel();
     121             : 
     122           1 :         MOCK_METHOD(void, write, (const uint8_t* buffer, size_t size, bool isEndOfPacket), (override));
     123           0 :         MOCK_METHOD(size_t, readTimeout, (uint8_t* buffer, size_t size, int timeout), (override));
     124             : };
     125             : 
     126             : class MockIdleController : public IIdleController {
     127           0 :         MOCK_METHOD(IIdleController::Phase, determinePhase, (int rpm, int targetRpm, SensorResult tps, float vss, float crankingTaperFraction), (override));
     128           0 :         MOCK_METHOD(int, getTargetRpm, (float clt), (override));
     129           0 :         MOCK_METHOD(float, getCrankingOpenLoop, (float clt), (const, override));
     130           0 :         MOCK_METHOD(float, getRunningOpenLoop, (IIdleController::Phase phase, float rpm, float clt, SensorResult tps), (override));
     131           0 :         MOCK_METHOD(float, getOpenLoop, (IIdleController::Phase phase, float rpm, float clt, SensorResult tps, float crankingTaperFraction), (override));
     132           0 :         MOCK_METHOD(float, getClosedLoop, (IIdleController::Phase phase, float tps, int rpm, int target), (override));
     133           0 :         MOCK_METHOD(float, getCrankingTaperFraction, (), (const, override));
     134           0 :         MOCK_METHOD(bool, isIdlingOrTaper, (), (const, override));
     135           0 :         MOCK_METHOD(float, getIdleTimingAdjustment, (int rpm), (override));
     136             : };