enhance AcPressureTest #6570

unit_tests/tests/ac/ac_pressure_test.cpp

@@ -17,6 +17,7 @@ namespace {
     };
 
     AcPressureTestConfig::AcPressureTestConfig() {
+        setAcDelay(0.0f);
         setMinAcPressure(TEST_MIN_AC_PRESSURE);
         setMaxAcPressure(TEST_MAX_AC_PRESSURE);
     }
@@ -38,8 +39,9 @@ namespace {
     void AcPressureTest::doTest(const AcPressureTestConfig& config, const std::vector<AcPressureTestData>& testData) {
         setUpTestConfig(config);
 
+        engineConfiguration->acDelay = 0;
         Sensor::setMockValue(SensorType::Rpm, 500); // to avoid engineTooSlow
-        engine->engineModules.get<AcController>()->acButtonState = true;
+        engine->engineState.lua.acRequestState = true; // to emulate pressed A/C button
 
         for (const AcPressureTestData& testDataItem: testData) {
             updateAcPressure(testDataItem.acPressure);
@@ -53,10 +55,18 @@ namespace {
                 engine->engineModules.get<AcController>()->acPressureTooHigh,
                 testDataItem.expectedAcPressureTooHigh
             ) << testDataItem.context;
+            const bool shouldAcBeEnabled = !testDataItem.expectedAcPressureTooLow
+                && !testDataItem.expectedAcPressureTooHigh;
+            EXPECT_EQ(engine->engineModules.get<AcController>()->isAcEnabled(), shouldAcBeEnabled)
+                << testDataItem.context;
+            EXPECT_EQ(engine->engineModules.get<AcController>()->acCompressorState, shouldAcBeEnabled)
+                << testDataItem.context;
+            EXPECT_EQ(enginePins.acRelay.getLogicValue(), shouldAcBeEnabled) << testDataItem.context;
         }
     }
 
     void AcPressureTest::checkPersistentIndicators() {
+        EXPECT_TRUE(engine->engineModules.get<AcController>()->acButtonState);
         EXPECT_FALSE(engine->engineModules.get<AcController>()->engineTooSlow);
         EXPECT_FALSE(engine->engineModules.get<AcController>()->engineTooFast);
         EXPECT_FALSE(engine->engineModules.get<AcController>()->noClt);

unit_tests/tests/ac/ac_test_base.cpp

@@ -12,10 +12,19 @@ void AcTestBase::updateAcPressure(float acPressure) {
 }
 
 void AcTestBase::setUpTestConfig(const AcTestConfig& config) {
+    configureAcDelay(config.getAcDelay());
     configureMinAcPressure(config.getMinAcPressure());
     configureMaxAcPressure(config.getMaxAcPressure());
 }
 
+void AcTestBase::configureAcDelay(const std::optional<float> acDelay) {
+    if (acDelay.has_value()) {
+        engineConfiguration->acDelay = acDelay.value();
+    } else {
+        ASSERT_EQ(engineConfiguration->acDelay, 0.5); // check default value
+    }
+}
+
 void AcTestBase::configureMinAcPressure(const std::optional<uint16_t> minAcPressure) {
     if (minAcPressure.has_value()) {
         engineConfiguration->minAcPressure = minAcPressure.value();

unit_tests/tests/ac/ac_test_base.h

@@ -8,12 +8,15 @@
 
 class AcTestConfig {
 public:
+    std::optional<float> getAcDelay() const { return m_acDelay; }
     std::optional<uint16_t> getMinAcPressure() const { return m_minAcPressure; }
     std::optional<uint16_t> getMaxAcPressure() const { return m_maxAcPressure; }
 protected:
+    void setAcDelay(const std::optional<float> value) { m_acDelay = value; }
     void setMinAcPressure(const std::optional<uint16_t> value) { m_minAcPressure = value; }
     void setMaxAcPressure(const std::optional<uint16_t> value) { m_maxAcPressure = value; }
 private:
+    std::optional<float> m_acDelay;
     std::optional<uint16_t> m_minAcPressure;
     std::optional<uint16_t> m_maxAcPressure;
 };
@@ -24,6 +27,7 @@ protected:
 
     void setUpTestConfig(const AcTestConfig& config);
 private:
+    void configureAcDelay(const std::optional<float> acDelay);
     void configureMinAcPressure(const std::optional<uint16_t> minAcPressure);
     void configureMaxAcPressure(const std::optional<uint16_t> maxAcPressure);
 };