ismail
a143484748
Break down tests into categories to improve maintainability and test granularity. This makes it easier to execute unit tests in CI/CD pipelines. Closes #1054.
285 lines
12 KiB
C
285 lines
12 KiB
C
#include "test_common.h"
|
|
|
|
|
|
// ### Tilt Functionality Tests (Conditional)
|
|
|
|
// This section will only be compiled if **`CONFIG_RELAY_CHN_ENABLE_TILTING`** is defined as **`1`** in `sdkconfig`.
|
|
|
|
#ifndef CONFIG_RELAY_CHN_ENABLE_TILTING
|
|
#error "This test requires CONFIG_RELAY_CHN_ENABLE_TILTING"
|
|
#endif
|
|
|
|
#define RELAY_CHN_CMD_FORWARD 1
|
|
#define RELAY_CHN_CMD_REVERSE 2
|
|
|
|
// Helper function to prepare channel for tilt tests
|
|
void prepare_channel_for_tilt(uint8_t chn_id, int initial_cmd) {
|
|
// Ensure the channel has had a 'last_run_cmd'
|
|
if (initial_cmd == RELAY_CHN_CMD_FORWARD) {
|
|
relay_chn_run_forward(chn_id);
|
|
} else { // Assuming initial_cmd is RELAY_CHN_CMD_REVERSE
|
|
relay_chn_run_reverse(chn_id);
|
|
}
|
|
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
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(chn_id));
|
|
}
|
|
|
|
// 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;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// Prepare channel by running forward first to set last_run_cmd
|
|
prepare_channel_for_tilt(ch, RELAY_CHN_CMD_FORWARD);
|
|
|
|
// 1. Start in forward direction
|
|
relay_chn_run_forward(ch);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
|
|
|
|
// 2. Issue tilt forward command
|
|
relay_chn_tilt_forward(ch);
|
|
// 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));
|
|
|
|
// Wait for the inertia period (after which the tilt command will be dispatched)
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// 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;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// Prepare channel by running reverse first to set last_run_cmd
|
|
prepare_channel_for_tilt(ch, RELAY_CHN_CMD_REVERSE);
|
|
|
|
// 1. Start in reverse direction
|
|
relay_chn_run_reverse(ch);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
|
|
|
|
// 2. Issue tilt reverse command
|
|
relay_chn_tilt_reverse(ch);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_STOPPED, relay_chn_get_state(ch));
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// TEST_CASE: 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]") {
|
|
uint8_t ch = 0;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 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_FREE, relay_chn_get_state(ch)); // Ensure we are back to FREE
|
|
|
|
// Issue tilt forward command
|
|
relay_chn_tilt_forward(ch);
|
|
// 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));
|
|
}
|
|
|
|
// TEST_CASE: 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]") {
|
|
uint8_t ch = 0;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 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_FREE, relay_chn_get_state(ch)); // Ensure we are back to FREE
|
|
|
|
// Issue tilt reverse command
|
|
relay_chn_tilt_reverse(ch);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// 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;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 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
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
|
|
|
|
// 2. Issue run forward command
|
|
relay_chn_run_forward(ch);
|
|
// 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));
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FORWARD, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// 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;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 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
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(ch));
|
|
|
|
// 2. Issue run reverse command
|
|
relay_chn_run_reverse(ch);
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE_PENDING, relay_chn_get_state(ch));
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// 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;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 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
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
|
|
|
|
// 2. Issue run reverse command (opposite direction)
|
|
relay_chn_run_reverse(ch);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_REVERSE, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// TEST_CASE: 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]") {
|
|
uint8_t ch = 0;
|
|
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 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
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(ch));
|
|
|
|
// 2. Issue stop command
|
|
relay_chn_stop(ch);
|
|
// 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_FREE, relay_chn_get_state(ch));
|
|
}
|
|
|
|
// ### Tilt Broadcast Command (RELAY_CHN_ID_ALL) Tests
|
|
|
|
TEST_CASE("tilt_forward with ID_ALL sets all channels to TILT_FORWARD", "[relay_chn][tilt][id_all]")
|
|
{
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 1. Prepare all channels.
|
|
for (uint8_t i = 0; i < relay_chn_count; i++) {
|
|
prepare_channel_for_tilt(i, RELAY_CHN_CMD_FORWARD);
|
|
}
|
|
|
|
// 2. Issue tilt forward to all channels
|
|
relay_chn_tilt_forward(RELAY_CHN_ID_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 < relay_chn_count; i++) {
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_FORWARD, relay_chn_get_state(i));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("tilt_reverse with ID_ALL sets all channels to TILT_REVERSE", "[relay_chn][tilt][id_all]")
|
|
{
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 1. Prepare all channels.
|
|
for (uint8_t i = 0; i < relay_chn_count; i++) {
|
|
prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
|
|
}
|
|
|
|
// 2. Issue tilt reverse to all channels
|
|
relay_chn_tilt_reverse(RELAY_CHN_ID_ALL);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
|
|
// 3. Verify all channels are tilting reverse
|
|
for (uint8_t i = 0; i < relay_chn_count; i++) {
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_TILT_REVERSE, relay_chn_get_state(i));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("tilt_stop with ID_ALL stops all tilting channels", "[relay_chn][tilt][id_all]")
|
|
{
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// 1. Prepare and start all channels tilting forward
|
|
for (uint8_t i = 0; i < relay_chn_count; i++) {
|
|
prepare_channel_for_tilt(i, RELAY_CHN_CMD_REVERSE);
|
|
}
|
|
relay_chn_tilt_forward(RELAY_CHN_ID_ALL);
|
|
vTaskDelay(pdMS_TO_TICKS(test_delay_margin_ms));
|
|
|
|
// 2. Stop tilting on all channels
|
|
relay_chn_tilt_stop(RELAY_CHN_ID_ALL);
|
|
vTaskDelay(pdMS_TO_TICKS(opposite_inertia_ms + test_delay_margin_ms));
|
|
|
|
// 3. Verify all channels are free
|
|
for (uint8_t i = 0; i < relay_chn_count; i++) {
|
|
TEST_ASSERT_EQUAL(RELAY_CHN_STATE_FREE, relay_chn_get_state(i));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("tilt_auto with ID_ALL tilts channels based on last run direction", "[relay_chn][tilt][id_all]")
|
|
{
|
|
TEST_ESP_OK(relay_chn_create(gpio_map, gpio_count));
|
|
g_is_component_initialized = true;
|
|
|
|
// This test requires at least 2 channels to demonstrate different behaviors
|
|
TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(2, 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);
|
|
|
|
// 2. Issue auto tilt command to all channels
|
|
relay_chn_tilt_auto(RELAY_CHN_ID_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));
|
|
} |