test_apps/main/test_relay_chn.c

@@ -15,11 +15,6 @@ const uint8_t gpio_count = sizeof(gpio_map) / sizeof(gpio_map[0]);
 // Assuming 2 GPIOs are used per channel
 const uint8_t relay_chn_count = gpio_count / 2; 
 
-// Retrieve inertia value from SDKconfig
-#ifndef CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS
-#define CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS 500 // Default if not defined in SDKconfig
-#endif
-
 const uint32_t opposite_inertia_ms = CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS;
 
 // Tolerant delay margin to ensure operations complete, especially after inertia.
@@ -27,40 +22,35 @@ const uint32_t test_delay_margin_ms = 50;
 
 // --- Test Setup/Teardown Functions ---
 void setUp(void) {
-    ESP_LOGI("TEST_SETUP", "Running setUp for relay_chn tests.");
     // Re-create the component before each test. relay_chn_create returns esp_err_t.
     TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
-    // Ensure all relays are stopped at the beginning, and transition to FREE state
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        relay_chn_stop(i); // relay_chn_stop returns void
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
-    }
-    ESP_LOGI("TEST_SETUP", "All channels initialized to RELAY_CHN_STATE_FREE.");
 }
 
 void tearDown(void) {
-    ESP_LOGI("TEST_TEARDOWN", "Running tearDown for relay_chn tests.");
+    
-    // Stop all relays after each test, and transition to FREE state
-    for (uint8_t i = 0; i < relay_chn_count; i++) {
-        relay_chn_stop(i); // relay_chn_stop returns void
-        vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms)); // Wait for FREE state
-    }
-    ESP_LOGI("TEST_TEARDOWN", "All channels returned to RELAY_CHN_STATE_FREE.");
 }
 
 // --- Basic Functionality Tests ---
 
 // TEST_CASE 1: Test that relay channels initialize correctly to RELAY_CHN_STATE_FREE
 TEST_CASE("Relay channels initialize correctly to FREE state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels initialize correctly to FREE state");
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
     }
 }
 
+// TEST_CASE 1: Test that relays do nothing when an invlid channel id given
+TEST_CASE("Run forward does nothing if channel id is invalid", "[relay_chn]") {
+    for (uint8_t i = relay_chn_count*2; i < relay_chn_count; i++) {
+        relay_chn_run_forward(i); // relay_chn_run_forward returns void
+        // Short delay for state to update
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
 // TEST_CASE 2: Test that relays run in the forward direction and update their state
 TEST_CASE("Relay channels run forward and update state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels run forward and update state");
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         relay_chn_run_forward(i); // relay_chn_run_forward returns void
         // Short delay for state to update
@@ -69,9 +59,18 @@ TEST_CASE("Relay channels run forward and update state", "[relay_chn]") {
     }
 }
 
-// TEST_CASE 3: Test that relays run in the reverse direction and update their state
+// TEST_CASE 3: Test that relays do nothing when an invlid channel id given
+TEST_CASE("Run reverse does nothing if channel id is invalid", "[relay_chn]") {
+    for (uint8_t i = relay_chn_count*2; i < relay_chn_count; i++) {
+        relay_chn_run_reverse(i); // relay_chn_run_forward returns void
+        // Short delay for state to update
+        vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
+    }
+}
+
+// TEST_CASE 4: Test that relays run in the reverse direction and update their state
 TEST_CASE("Relay channels run reverse and update state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels run reverse and update state");
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         relay_chn_run_reverse(i); // relay_chn_run_reverse returns void
         vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
@@ -79,10 +78,9 @@ TEST_CASE("Relay channels run reverse and update state", "[relay_chn]") {
     }
 }
 
-// TEST_CASE 4: Test that relays stop and transition to RELAY_CHN_STATE_FREE
+// TEST_CASE 5: Test that relays stop and transition to RELAY_CHN_STATE_FREE
 // This test also verifies the transition to FREE state after a STOP command.
 TEST_CASE("Relay channels stop and update to FREE state", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Relay channels stop and update to FREE state");
     for (uint8_t i = 0; i < relay_chn_count; i++) {
         // First, run forward to test stopping and transitioning to FREE state
         relay_chn_run_forward(i); // relay_chn_run_forward returns void
@@ -101,28 +99,34 @@ TEST_CASE("Relay channels stop and update to FREE state", "[relay_chn]") {
     }
 }
 
-// TEST_CASE 5: Test function calls with invalid channel IDs
+// TEST_CASE 6: Get state should return UNDEFINED when id is not valid
-// TEST_CASE("Invalid channel ID handling", "[relay_chn]") {
+TEST_CASE("Get state returns UNDEFINED when id is invalid", "[relay_chn]") {
-//     ESP_LOGI("TEST", "Running test: Invalid channel ID handling");
+    for (uint8_t i = relay_chn_count*2; i < relay_chn_count; i++) {
-//     uint8_t invalid_channel_id = relay_chn_count + 1; // An ID that is out of bounds
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_UNDEFINED, relay_chn_get_state(i));
+    }
+    // Test for running states also
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    for (uint8_t i = relay_chn_count*2; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL(RELAY_CHN_STATE_UNDEFINED, relay_chn_get_state(i));
+    }
+}
 
-//     // These calls are expected to return ESP_ERR_INVALID_ARG, so TEST_ASSERT_EQUAL is appropriate.
+// TEST_CASE 7: Get state string should return "UNKNOWN" when id is not valid
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_run_forward(invalid_channel_id));
+TEST_CASE("Get state string returns UNKNOWN when id is invalid", "[relay_chn]") {
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_run_reverse(invalid_channel_id));
+    for (uint8_t i = relay_chn_count*2; i < relay_chn_count; i++) {
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_stop(invalid_channel_id));
+        TEST_ASSERT_EQUAL_STRING("UNKNOWN", relay_chn_get_state_str(i));
+    }
+    // Test for running states also
+    relay_chn_run_forward(RELAY_CHN_ID_ALL);
+    vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
+    for (uint8_t i = relay_chn_count*2; i < relay_chn_count; i++) {
+        TEST_ASSERT_EQUAL_STRING("UNKNOWN", relay_chn_get_state_str(i));
+    }
+}
 
-//     // Test tilt commands only if tilt functionality is enabled
+// TEST_CASE 8: Test independent operation of multiple relay channels
-// #if CONFIG_RELAY_CHN_ENABLE_TILTING == 1
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_tilt_forward(invalid_channel_id));
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_tilt_reverse(invalid_channel_id));
-// #endif
-    
-//     TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_get_state(invalid_channel_id));
-// }
-
-// TEST_CASE 6: Test independent operation of multiple relay channels
 TEST_CASE("Multiple channels can operate independently", "[relay_chn]") {
-    ESP_LOGI("TEST", "Running test: Multiple channels can operate independently");
     if (relay_chn_count >= 2) {
         // Start Channel 0 in forward direction
         relay_chn_run_forward(0); // relay_chn_run_forward returns void
@@ -160,7 +164,6 @@ TEST_CASE("Multiple channels can operate independently", "[relay_chn]") {
 // TEST_CASE 7: Test transition from forward to reverse with inertia and state checks
 // Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_REVERSE
 TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: Forward to Reverse transition with opposite inertia");
     uint8_t ch = 0; // Channel to test
 
     // 1. Start in forward direction
@@ -182,7 +185,6 @@ TEST_CASE("Forward to Reverse transition with opposite inertia", "[relay_chn][in
 // TEST_CASE 8: Test transition from reverse to forward with inertia and state checks
 // Scenario: RELAY_CHN_STATE_REVERSE -> (relay_chn_run_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: Reverse to Forward transition with opposite inertia");
     uint8_t ch = 0;
 
     // 1. Start in reverse direction
@@ -203,7 +205,6 @@ TEST_CASE("Reverse to Forward transition with opposite inertia", "[relay_chn][in
 // TEST_CASE 9: Test issuing the same run command while already running (no inertia expected)
 // Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: Running in same direction does not incur inertia");
     uint8_t ch = 0;
 
     // 1. Start in forward direction
@@ -222,7 +223,6 @@ TEST_CASE("Running in same direction does not incur inertia", "[relay_chn][inert
 // TEST_CASE 10: Test transition from FREE state to running (no inertia expected)
 // Scenario: RELAY_CHN_STATE_FREE -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("FREE to Running transition without inertia", "[relay_chn][inertia]") {
-    ESP_LOGI("TEST", "Running test: FREE to Running transition without inertia");
     uint8_t ch = 0;
 
     // setUp() should have already brought the channel to FREE state
@@ -262,7 +262,6 @@ void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
 // TEST_CASE 11: Test transition from running forward to tilt forward
 // Scenario: RELAY_CHN_STATE_FORWARD -> (relay_chn_tilt_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_FORWARD
 TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Run Forward to Tilt Forward transition with inertia");
     uint8_t ch = 0;
 
     // Prepare channel by running forward first to set last_run_cmd
@@ -287,7 +286,6 @@ TEST_CASE("Run Forward to Tilt Forward transition with inertia", "[relay_chn][ti
 // TEST_CASE 12: Test transition from running reverse to tilt reverse
 // Scenario: RELAY_CHN_STATE_REVERSE -> (relay_chn_tilt_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_REVERSE
 TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Run Reverse to Tilt Reverse transition with inertia");
     uint8_t ch = 0;
 
     // Prepare channel by running reverse first to set last_run_cmd
@@ -310,7 +308,6 @@ TEST_CASE("Run Reverse to Tilt Reverse transition with inertia", "[relay_chn][ti
 // TEST_CASE 13: Test transition from FREE state to tilt forward (now with preparation)
 // Scenario: RELAY_CHN_STATE_FREE -> (prepare) -> RELAY_CHN_STATE_FREE -> (relay_chn_tilt_forward) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_FORWARD
 TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: FREE to Tilt Forward transition with inertia (prepared)");
     uint8_t ch = 0;
 
     // Prepare channel by running forward first to set last_run_cmd
@@ -327,7 +324,6 @@ TEST_CASE("FREE to Tilt Forward transition with inertia (prepared)", "[relay_chn
 // TEST_CASE 14: Test transition from FREE state to tilt reverse (now with preparation)
 // Scenario: RELAY_CHN_STATE_FREE -> (prepare) -> RELAY_CHN_STATE_FREE -> (relay_chn_tilt_reverse) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_TILT_REVERSE
 TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: FREE to Tilt Reverse transition with inertia (prepared)");
     uint8_t ch = 0;
 
     // Prepare channel by running reverse first to set last_run_cmd
@@ -343,7 +339,6 @@ TEST_CASE("FREE to Tilt Reverse transition with inertia (prepared)", "[relay_chn
 // TEST_CASE 15: Test transition from tilt forward to run forward (inertia expected for run)
 // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_run_forward) -> RELAY_CHN_STATE_FORWARD
 TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt Forward to Run Forward transition with inertia");
     uint8_t ch = 0;
 
     // Prepare channel by running forward first to set last_run_cmd, then tilt
@@ -363,7 +358,6 @@ TEST_CASE("Tilt Forward to Run Forward transition with inertia", "[relay_chn][ti
 // TEST_CASE 16: Test transition from tilt reverse to run reverse (no inertia expected for run)
 // Scenario: RELAY_CHN_STATE_TILT_REVERSE -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_REVERSE
 TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt Reverse to Run Reverse transition with inertia");
     uint8_t ch = 0;
 
     // Prepare channel by running reverse first to set last_run_cmd, then tilt
@@ -382,7 +376,6 @@ TEST_CASE("Tilt Reverse to Run Reverse transition with inertia", "[relay_chn][ti
 // TEST_CASE 17: Test transition from tilt forward to run reverse (without inertia)
 // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_run_reverse) -> RELAY_CHN_STATE_REVERSE
 TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt Forward to Run Reverse transition without inertia");
     uint8_t ch = 0;
 
     // Prepare channel by running forward first to set last_run_cmd, then tilt
@@ -400,7 +393,6 @@ TEST_CASE("Tilt Forward to Run Reverse transition without inertia", "[relay_chn]
 // TEST_CASE 18: Test stopping from a tilt state (no inertia for stop command itself)
 // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_stop) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_FREE
 TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_chn][tilt][inertia]") {
-    ESP_LOGI("TEST", "Running test: Tilt to Stop transition without immediate inertia for stop");
     uint8_t ch = 0;
 
     // Prepare channel by running forward first to set last_run_cmd, then tilt
@@ -420,7 +412,6 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_
 // If tilt functionality is disabled, these tests are skipped.
 // A dummy test case is added to indicate this in the test output.
 TEST_CASE("Tilt functionality is disabled, skipping tilt tests", "[relay_chn][tilt_disabled]") {
-    ESP_LOGI("TEST", "Tilt functionality is disabled (CONFIG_RELAY_CHN_ENABLE_TILTING is 0). Skipping tilt tests.");
     TEST_ASSERT_TRUE(true); // Just to ensure at least one test passes for visibility
 }
 #endif // CONFIG_RELAY_CHN_ENABLE_TILTING
@@ -430,13 +421,10 @@ TEST_CASE("Tilt functionality is disabled, skipping tilt tests", "[relay_chn][ti
 
 // --- app_main function ---
 void app_main(void) {
-    ESP_LOGI("APP_MAIN", "Starting relay_chn unit tests...");
-
     // Run the Unity test runner
     unity_run_all_tests();
 
     // After tests complete, instead of restarting, the device will halt.
-    ESP_LOGI("APP_MAIN", "All relay_chn tests completed. Device halted.");
     while (1) {
         vTaskDelay(pdMS_TO_TICKS(1000)); // Wait with low power consumption
     }

test_apps/sdkconfig

@@ -79,7 +79,6 @@ CONFIG_SOC_ADC_SHARED_POWER=y
 CONFIG_SOC_APB_BACKUP_DMA=y
 CONFIG_SOC_BROWNOUT_RESET_SUPPORTED=y
 CONFIG_SOC_SHARED_IDCACHE_SUPPORTED=y
-CONFIG_SOC_CACHE_FREEZE_SUPPORTED=y
 CONFIG_SOC_CACHE_MEMORY_IBANK_SIZE=0x4000
 CONFIG_SOC_CPU_CORES_NUM=1
 CONFIG_SOC_CPU_INTR_NUM=32