From 15d1673e773bb216caabff8cdd2f999df4e7e32f Mon Sep 17 00:00:00 2001 From: ismail Date: Tue, 26 Aug 2025 15:03:16 +0300 Subject: [PATCH] Refactor and improve for batch operations Refactor tilt test functions to use batch operations for all channels and improve state checks. Refs #1085 --- test_apps/main/test_relay_chn_tilt_multi.c | 268 +++++++++++---------- 1 file changed, 142 insertions(+), 126 deletions(-) diff --git a/test_apps/main/test_relay_chn_tilt_multi.c b/test_apps/main/test_relay_chn_tilt_multi.c index 7aa1034..5fab474 100644 --- a/test_apps/main/test_relay_chn_tilt_multi.c +++ b/test_apps/main/test_relay_chn_tilt_multi.c @@ -12,171 +12,197 @@ #define RELAY_CHN_CMD_FORWARD 1 #define RELAY_CHN_CMD_REVERSE 2 +void check_all_channels_for_state(relay_chn_state_t state) +{ + for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { + TEST_ASSERT_EQUAL(state, relay_chn_get_state(i)); + } +} + // Helper function to prepare channel for tilt tests -void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) { +void prepare_channels_for_tilt_with_mixed_runs() { // Ensure the channel reset tilt control - relay_chn_tilt_stop(chn_id); + relay_chn_tilt_stop_all(); + vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); + + // Ensure the channel has had a 'last_run_cmd' + for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { + if (i % 2 == 0) { + relay_chn_run_forward(i); + } else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE + relay_chn_run_reverse(i); + } + } + + vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Allow command to process + relay_chn_stop_all(); // Stop it to set last_run_cmd but return to FREE for next test vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); + check_all_channels_for_state(RELAY_CHN_STATE_IDLE); +} + +// Helper function to prepare channel for tilt tests +void prepare_all_channels_for_tilt(int initial_cmd) { + // Ensure the channel reset tilt control + relay_chn_tilt_stop_all(); + vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); + + // If the channels are not IDLE yet, wait more + bool not_idle = false; + for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { + if (relay_chn_get_state(i) != RELAY_CHN_STATE_IDLE) { + not_idle = true; + break; + } + } + + if (not_idle) { + vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS)); + } // Ensure the channel has had a 'last_run_cmd' if (initial_cmd == RELAY_CHN_CMD_FORWARD) { - relay_chn_run_forward(chn_id); + relay_chn_run_forward_all(); } else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE - relay_chn_run_reverse(chn_id); + relay_chn_run_reverse_all(); } vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Allow command to process - relay_chn_stop(chn_id); // Stop it to set last_run_cmd but return to FREE for next test + relay_chn_stop_all(); // Stop all to set last_run_cmd but return to FREE for next test vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(chn_id)); + + check_all_channels_for_state(RELAY_CHN_STATE_IDLE); } // TEST_CASE: 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]") { - uint8_t ch = 0; - // Prepare channel by running forward first to set last_run_cmd - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); // 1. Start in forward direction - relay_chn_run_forward(ch); + relay_chn_run_forward_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_FORWARD); // 2. Issue tilt forward command - relay_chn_tilt_forward(ch); + relay_chn_tilt_forward_all(); // After tilt command, it should immediately stop and then trigger inertia. vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_STOPPED); // Wait for the inertia period (after which the tilt command will be dispatched) - vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); + vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); } // TEST_CASE: 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]") { - uint8_t ch = 0; - // Prepare channel by running reverse first to set last_run_cmd - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE); + prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE); // 1. Start in reverse direction - relay_chn_run_reverse(ch); + relay_chn_run_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_REVERSE); // 2. Issue tilt reverse command - relay_chn_tilt_reverse(ch); + relay_chn_tilt_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_STOPPED); vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE); } // TEST_CASE: Test transition from FREE state to tilt forward (now with preparation) // Scenario: RELAY_CHN_STATE_IDLE -> (prepare) -> RELAY_CHN_STATE_IDLE -> (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]") { - uint8_t ch = 0; - // Prepare channel by running forward first to set last_run_cmd - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch)); // Ensure we are back to FREE + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); // Issue tilt forward command - relay_chn_tilt_forward(ch); + relay_chn_tilt_forward_all(); // From FREE state, tilt command should still incur the inertia due to the internal timer logic vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); } // TEST_CASE: Test transition from FREE state to tilt reverse (now with preparation) // Scenario: RELAY_CHN_STATE_IDLE -> (prepare) -> RELAY_CHN_STATE_IDLE -> (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]") { - uint8_t ch = 0; - // Prepare channel by running reverse first to set last_run_cmd - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch)); // Ensure we are back to FREE + prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE); // Issue tilt reverse command - relay_chn_tilt_reverse(ch); + relay_chn_tilt_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE); } // TEST_CASE: 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]") { - uint8_t ch = 0; - // Prepare channel by running forward first to set last_run_cmd, then tilt - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); - relay_chn_tilt_forward(ch); // Go to tilt state + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_forward_all(); // Go to tilt state vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); // 2. Issue run forward command - relay_chn_run_forward(ch); + relay_chn_run_forward_all(); // From Tilt to Run in the same logical name but in the opposite direction, inertia is expected. - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD_PENDING, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_FORWARD_PENDING); vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_FORWARD); } // TEST_CASE: 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]") { - uint8_t ch = 0; - // Prepare channel by running reverse first to set last_run_cmd, then tilt - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE); - relay_chn_tilt_reverse(ch); // Go to tilt state + prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE); + relay_chn_tilt_reverse_all(); // Go to tilt state vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE); // 2. Issue run reverse command - relay_chn_run_reverse(ch); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state(ch)); + relay_chn_run_reverse_all(); + check_all_channels_for_state(RELAY_CHN_STATE_REVERSE_PENDING); vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_REVERSE); } // TEST_CASE: 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]") { - uint8_t ch = 0; - // Prepare channel by running forward first to set last_run_cmd, then tilt - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); - relay_chn_tilt_forward(ch); // Go to tilt state + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_forward_all(); // Go to tilt state vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); // 2. Issue run reverse command (opposite direction) - relay_chn_run_reverse(ch); + relay_chn_run_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_REVERSE); } // TEST_CASE: Test stopping from a tilt state (no inertia for stop command itself) // Scenario: RELAY_CHN_STATE_TILT_FORWARD -> (relay_chn_tilt_stop) -> RELAY_CHN_STATE_STOPPED -> (inertia) -> RELAY_CHN_STATE_IDLE TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_chn][tilt][inertia]") { - uint8_t ch = 0; - - // Prepare channel by running forward first to set last_run_cmd, then tilt - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); - relay_chn_tilt_forward(ch); // Go to tilt state + // Prepare all channels by running forward first to set last_run_cmd, then tilt + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_forward_all(); // Go to tilt state vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); + // Verify all channels are tilting forward + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); // 2. Issue stop command - relay_chn_tilt_stop(ch); + relay_chn_tilt_stop_all(); // Stop command should apply immediately, setting state to FREE since last state was tilt. - vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(ch)); + vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); + // Verify all channels are IDLE + check_all_channels_for_state(RELAY_CHN_STATE_IDLE); } // ### Batch Tilt Control Tests @@ -184,44 +210,34 @@ TEST_CASE("Tilt to Stop transition without immediate inertia for stop", "[relay_ TEST_CASE("tilt_forward_all sets all channels to TILT_FORWARD", "[relay_chn][tilt][batch]") { // 1. Prepare all channels. - for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - prepare_channel_for_tilt(i, RELAY_CHN_CMD_FORWARD); - } + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); // 2. Issue tilt forward to all channels relay_chn_tilt_forward_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Tilt from FREE doesn't have stop-inertia // 3. Verify all channels are tilting forward - for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - ESP_LOGI(TEST_TAG, "Checking channel %d", i); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(i)); - } + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); } TEST_CASE("tilt_reverse_all sets all channels to TILT_REVERSE", "[relay_chn][tilt][batch]") { // 1. Prepare all channels. - for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE); - } + prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE); // 2. Issue tilt reverse to all channels relay_chn_tilt_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // 3. Verify all channels are tilting reverse - for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(i)); - } + check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE); } TEST_CASE("tilt_stop_all stops all tilting channels", "[relay_chn][tilt][batch]") { // 1. Prepare and start all channels tilting forward - for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE); - } + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_forward_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); @@ -230,10 +246,7 @@ TEST_CASE("tilt_stop_all stops all tilting channels", "[relay_chn][tilt][batch]" vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); // 3. Verify all channels are free - for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { - ESP_LOGI(TEST_TAG, "Checking channel %d", i); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_IDLE, relay_chn_get_state(i)); - } + check_all_channels_for_state(RELAY_CHN_STATE_IDLE); } TEST_CASE("tilt_auto_all tilts channels based on last run direction", "[relay_chn][tilt][batch]") @@ -242,34 +255,39 @@ TEST_CASE("tilt_auto_all tilts channels based on last run direction", "[relay_ch TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(2, CONFIG_RELAY_CHN_COUNT, "Test requires at least 2 channels"); // 1. Prepare channel 0 with last run FORWARD and channel 1 with last run REVERSE - prepare_channel_for_tilt(0, RELAY_CHN_CMD_FORWARD); - prepare_channel_for_tilt(1, RELAY_CHN_CMD_REVERSE); + prepare_channels_for_tilt_with_mixed_runs(0, RELAY_CHN_CMD_FORWARD); // 2. Issue auto tilt command to all channels relay_chn_tilt_auto_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Tilt from FREE state is dispatched immediately - // 3. Verify channel 0 tilts forward (last run was forward) and channel 1 tilts reverse (last run was reverse) - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(0)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(1)); + // 3. Verify even channels tilt forward (last run was forward) and odd channels tilt reverse (last run was reverse) + for (int i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) { + relay_chn_state_t state = i % 2 == 0 ? + RELAY_CHN_STATE_TILT_FORWARD : RELAY_CHN_STATE_TILT_REVERSE; + + TEST_ASSERT_EQUAL(state, relay_chn_get_state(i)); + } } // Test relay_chn_tilt_auto() chooses correct tilt direction TEST_CASE("relay_chn_tilt_auto chooses correct direction", "[relay_chn][tilt][auto]") { - uint8_t ch = 0; // Prepare FORWARD - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); - relay_chn_tilt_auto(ch); + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_auto_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); - relay_chn_tilt_stop(ch); + // Verify all tilt forward + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); + + relay_chn_tilt_stop_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Prepare REVERSE - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE); - relay_chn_tilt_auto(ch); + prepare_all_channels_for_tilt(RELAY_CHN_CMD_REVERSE); + relay_chn_tilt_auto_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch)); + // Verify all tilt reverse + check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE); } // Test sensitivity set/get @@ -296,49 +314,47 @@ TEST_CASE("relay_chn_tilt_set_sensitivity and get", "[relay_chn][tilt][sensitivi // Test tilt counter logic: forward x3, reverse x3, extra reverse fails TEST_CASE("tilt counter logic: forward and reverse consumption", "[relay_chn][tilt][counter]") { - uint8_t ch = 0; - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); + +// Tilt execution time at 100% sensitivity in milliseconds (10 + 90) +#define TEST_TILT_EXECUTION_TIME_MS 100 + + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_set_sensitivity_all_with(100); // Set sentivity to max for fastest execution // Tilt forward 3 times for (int i = 0; i < 3; ++i) { - relay_chn_tilt_forward(ch); - vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); - relay_chn_tilt_stop(ch); - vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); + relay_chn_tilt_forward_all(); + vTaskDelay(pdMS_TO_TICKS(TEST_TILT_EXECUTION_TIME_MS)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); + relay_chn_tilt_stop_all(); } + vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); // Now tilt reverse 3 times (should succeed) for (int i = 0; i < 3; ++i) { - relay_chn_tilt_reverse(ch); - vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - if (i < 3) { - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch)); - relay_chn_tilt_stop(ch); - vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - } + relay_chn_tilt_reverse_all(); + vTaskDelay(pdMS_TO_TICKS(TEST_TILT_EXECUTION_TIME_MS)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_REVERSE); + relay_chn_tilt_stop_all(); } // Extra reverse tilt should fail (counter exhausted) - relay_chn_tilt_reverse(ch); + relay_chn_tilt_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - // Should not enter TILT_REVERSE, should remain FREE or STOPPED - relay_chn_state_t state = relay_chn_get_state(ch); - TEST_ASSERT(state != RELAY_CHN_STATE_TILT_REVERSE); + // Should not enter TILT_REVERSE, should remain IDLE + check_all_channels_for_state(RELAY_CHN_STATE_IDLE); } // Test run command during TILT state TEST_CASE("run command during TILT state transitions correctly", "[relay_chn][tilt][run-during-tilt]") { - uint8_t ch = 0; - prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD); - relay_chn_tilt_forward(ch); + prepare_all_channels_for_tilt(RELAY_CHN_CMD_FORWARD); + relay_chn_tilt_forward_all(); vTaskDelay(pdMS_TO_TICKS(CONFIG_RELAY_CHN_OPPOSITE_INERTIA_MS + TEST_DELAY_MARGIN_MS)); - TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch)); + check_all_channels_for_state(RELAY_CHN_STATE_TILT_FORWARD); // Issue run reverse while in TILT_FORWARD - relay_chn_run_reverse(ch); + relay_chn_run_reverse_all(); vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_MARGIN_MS)); - // Should transition to REVERSE or REVERSE_PENDING depending on inertia logic - relay_chn_state_t state = relay_chn_get_state(ch); - TEST_ASSERT(state == RELAY_CHN_STATE_REVERSE || state == RELAY_CHN_STATE_REVERSE_PENDING); + // Should transition to REVERSE + check_all_channels_for_state(RELAY_CHN_STATE_REVERSE); } \ No newline at end of file