diff --git a/speeduino/scheduler.h b/speeduino/scheduler.h index ec2fb3c5..627b2373 100644 --- a/speeduino/scheduler.h +++ b/speeduino/scheduler.h @@ -25,6 +25,8 @@ See page 136 of the processors datasheet: www.atmel.com/Images/doc2549.pdf #ifndef SCHEDULER_H #define SCHEDULER_H +#include "globals.h" + #define USE_IGN_REFRESH #define IGNITION_REFRESH_THRESHOLD 30 //Time in uS that the refresh functions will check to ensure there is enough time before changing the end compare @@ -47,7 +49,7 @@ void setIgnitionSchedule6(void (*startCallback)(), unsigned long timeout, unsign void setIgnitionSchedule7(void (*startCallback)(), unsigned long timeout, unsigned long duration, void(*endCallback)()); void setIgnitionSchedule8(void (*startCallback)(), unsigned long timeout, unsigned long duration, void(*endCallback)()); -static inline void refreshIgnitionSchedule1(unsigned long timeToEnd) __attribute__((always_inline)); +inline void refreshIgnitionSchedule1(unsigned long timeToEnd) __attribute__((always_inline)); //The ARM cores use seprate functions for their ISRs #if defined(CORE_STM32_OFFICIAL) || defined(CORE_STM32_GENERIC) || defined(CORE_TEENSY) diff --git a/speeduino/scheduler.ino b/speeduino/scheduler.ino index 1884e524..a8526bc9 100644 --- a/speeduino/scheduler.ino +++ b/speeduino/scheduler.ino @@ -458,7 +458,7 @@ void setIgnitionSchedule1(void (*startCallback)(), unsigned long timeout, unsign } } -static inline void refreshIgnitionSchedule1(unsigned long timeToEnd) +inline void refreshIgnitionSchedule1(unsigned long timeToEnd) { if( (ignitionSchedule1.Status == RUNNING) && (timeToEnd < ignitionSchedule1.duration) ) //Must have the threshold check here otherwise it can cause a condition where the compare fires twice, once after the other, both for the end diff --git a/test/tests_corrections.cpp b/test/test_generic/tests_corrections.cpp similarity index 100% rename from test/tests_corrections.cpp rename to test/test_generic/tests_corrections.cpp diff --git a/test/tests_corrections.h b/test/test_generic/tests_corrections.h similarity index 100% rename from test/tests_corrections.h rename to test/test_generic/tests_corrections.h diff --git a/test/tests_init.cpp b/test/test_generic/tests_init.cpp similarity index 100% rename from test/tests_init.cpp rename to test/test_generic/tests_init.cpp diff --git a/test/tests_init.h b/test/test_generic/tests_init.h similarity index 100% rename from test/tests_init.h rename to test/test_generic/tests_init.h diff --git a/test/tests_main.cpp b/test/test_generic/tests_main.cpp similarity index 50% rename from test/tests_main.cpp rename to test/test_generic/tests_main.cpp index dc644579..e02590b2 100644 --- a/test/tests_main.cpp +++ b/test/test_generic/tests_main.cpp @@ -3,27 +3,33 @@ #include "tests_corrections.h" #include "tests_init.h" -#include "tests_schedules.h" -void setup() { +void doTests() +{ + testInitialisation(); + testCorrections(); +} + +void setup() +{ + pinMode(LED_BUILTIN, OUTPUT); + // NOTE!!! Wait for >2 secs // if board doesn't support software reset via Serial.DTR/RTS delay(2000); UNITY_BEGIN(); // IMPORTANT LINE! - pinMode(LED_BUILTIN, OUTPUT); - + doTests(); + + UNITY_END(); // stop unit testing } -uint8_t i = 0; -uint8_t max_blinks = 5; - -void loop() +void loop() { - testInitialisation(); - testCorrections(); - testSchedules(); - - UNITY_END(); // stop unit testing + // Blink to indicate end of test + digitalWrite(LED_BUILTIN, HIGH); + delay(250); + digitalWrite(LED_BUILTIN, LOW); + delay(250); } \ No newline at end of file diff --git a/test/test_schedule/test_accuracy_duration.cpp b/test/test_schedule/test_accuracy_duration.cpp new file mode 100644 index 00000000..51737dfe --- /dev/null +++ b/test/test_schedule/test_accuracy_duration.cpp @@ -0,0 +1,204 @@ + +#include +#include + +#include "scheduler.h" + +#define TIMEOUT 1000 +#define DURATION 1000 +#define DELTA 20 + +static uint32_t start_time, end_time; +static void startCallback(void) { start_time = micros(); } +static void endCallback(void) { end_time = micros(); } + +void test_accuracy_duration_inj1(void) +{ + initialiseSchedulers(); + setFuelSchedule1(TIMEOUT, DURATION); + while(fuelSchedule1.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule1.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +} + +void test_accuracy_duration_inj2(void) +{ + initialiseSchedulers(); + setFuelSchedule2(TIMEOUT, DURATION); + while(fuelSchedule2.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule2.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +} + +void test_accuracy_duration_inj3(void) +{ + initialiseSchedulers(); + setFuelSchedule3(TIMEOUT, DURATION); + while(fuelSchedule3.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule3.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +} + +void test_accuracy_duration_inj4(void) +{ + initialiseSchedulers(); + setFuelSchedule4(TIMEOUT, DURATION); + while(fuelSchedule4.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule4.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +} + +void test_accuracy_duration_inj5(void) +{ +#if INJ_CHANNELS >= 5 + initialiseSchedulers(); + setFuelSchedule5(TIMEOUT, DURATION); + while(fuelSchedule5.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule5.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +#endif +} + +void test_accuracy_duration_inj6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setFuelSchedule6(TIMEOUT, DURATION); + while(fuelSchedule6.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule6.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +#endif +} + +void test_accuracy_duration_inj7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setFuelSchedule7(TIMEOUT, DURATION); + while(fuelSchedule7.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule7.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +#endif +} + +void test_accuracy_duration_inj8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setFuelSchedule8(TIMEOUT, DURATION); + while(fuelSchedule8.Status == PENDING) /*Wait*/ ; + start_time = micros(); + while(fuelSchedule8.Status == RUNNING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +#endif +} + + + +void test_accuracy_duration_ign1(void) +{ + initialiseSchedulers(); + setIgnitionSchedule1(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule1.Status == PENDING) || (ignitionSchedule1.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time); +} + +void test_accuracy_duration_ign2(void) +{ + initialiseSchedulers(); + setIgnitionSchedule2(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule2.Status == PENDING) || (ignitionSchedule2.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_duration_ign3(void) +{ + initialiseSchedulers(); + setIgnitionSchedule3(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule3.Status == PENDING) || (ignitionSchedule3.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_duration_ign4(void) +{ + initialiseSchedulers(); + setIgnitionSchedule4(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule4.Status == PENDING) || (ignitionSchedule4.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_duration_ign5(void) +{ +#if IGN_CHANNELS >= 5 + initialiseSchedulers(); + setIgnitionSchedule5(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule5.Status == PENDING) || (ignitionSchedule5.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_duration_ign6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setIgnitionSchedule6(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule6.Status == PENDING) || (ignitionSchedule6.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_duration_ign7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setIgnitionSchedule7(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule7.Status == PENDING) || (ignitionSchedule7.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_duration_ign8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setIgnitionSchedule8(startCallback, TIMEOUT, DURATION, endCallback); + while( (ignitionSchedule8.Status == PENDING) || (ignitionSchedule8.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_duration(void) +{ + RUN_TEST(test_accuracy_duration_inj1); + RUN_TEST(test_accuracy_duration_inj2); + RUN_TEST(test_accuracy_duration_inj3); + RUN_TEST(test_accuracy_duration_inj4); + RUN_TEST(test_accuracy_duration_inj5); + RUN_TEST(test_accuracy_duration_inj6); + RUN_TEST(test_accuracy_duration_inj7); + RUN_TEST(test_accuracy_duration_inj8); + + RUN_TEST(test_accuracy_duration_ign1); + RUN_TEST(test_accuracy_duration_ign2); + RUN_TEST(test_accuracy_duration_ign3); + RUN_TEST(test_accuracy_duration_ign4); + RUN_TEST(test_accuracy_duration_ign5); + RUN_TEST(test_accuracy_duration_ign6); + RUN_TEST(test_accuracy_duration_ign7); + RUN_TEST(test_accuracy_duration_ign8); +} diff --git a/test/test_schedule/test_accuracy_timeout.cpp b/test/test_schedule/test_accuracy_timeout.cpp new file mode 100644 index 00000000..aad2e467 --- /dev/null +++ b/test/test_schedule/test_accuracy_timeout.cpp @@ -0,0 +1,203 @@ + +#include +#include + +#include "scheduler.h" + +#define TIMEOUT 1000 +#define DURATION 1000 +#define DELTA 20 + +static uint32_t start_time, end_time; +static void startCallback(void) { end_time = micros(); } +static void endCallback(void) { /*Empty*/ } + +void test_accuracy_timeout_inj1(void) +{ + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule1(TIMEOUT, DURATION); + while(fuelSchedule1.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_inj2(void) +{ + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule2(TIMEOUT, DURATION); + while(fuelSchedule2.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_inj3(void) +{ + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule3(TIMEOUT, DURATION); + while(fuelSchedule3.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_inj4(void) +{ + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule4(TIMEOUT, DURATION); + while(fuelSchedule4.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_inj5(void) +{ +#if INJ_CHANNELS >= 5 + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule5(TIMEOUT, DURATION); + while(fuelSchedule5.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout_inj6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule6(TIMEOUT, DURATION); + while(fuelSchedule6.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout_inj7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule7(TIMEOUT, DURATION); + while(fuelSchedule7.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout_inj8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + start_time = micros(); + setFuelSchedule8(TIMEOUT, DURATION); + while(fuelSchedule8.Status == PENDING) /*Wait*/ ; + end_time = micros(); + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + + +void test_accuracy_timeout_ign1(void) +{ + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule1(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule1.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_ign2(void) +{ + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule2(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule2.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_ign3(void) +{ + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule3(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule3.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_ign4(void) +{ + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule4(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule4.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +} + +void test_accuracy_timeout_ign5(void) +{ +#if IGN_CHANNELS >= 5 + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule5(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule5.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout_ign6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule6(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule6.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout_ign7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule7(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule7.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout_ign8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + start_time = micros(); + setIgnitionSchedule8(startCallback, TIMEOUT, DURATION, endCallback); + while(ignitionSchedule8.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time); +#endif +} + +void test_accuracy_timeout(void) +{ + RUN_TEST(test_accuracy_timeout_inj1); + RUN_TEST(test_accuracy_timeout_inj2); + RUN_TEST(test_accuracy_timeout_inj3); + RUN_TEST(test_accuracy_timeout_inj4); + RUN_TEST(test_accuracy_timeout_inj5); + RUN_TEST(test_accuracy_timeout_inj6); + RUN_TEST(test_accuracy_timeout_inj7); + RUN_TEST(test_accuracy_timeout_inj8); + + RUN_TEST(test_accuracy_timeout_ign1); + RUN_TEST(test_accuracy_timeout_ign2); + RUN_TEST(test_accuracy_timeout_ign3); + RUN_TEST(test_accuracy_timeout_ign4); + RUN_TEST(test_accuracy_timeout_ign5); + RUN_TEST(test_accuracy_timeout_ign6); + RUN_TEST(test_accuracy_timeout_ign7); + RUN_TEST(test_accuracy_timeout_ign8); +} diff --git a/test/test_schedule/test_schedule.cpp b/test/test_schedule/test_schedule.cpp new file mode 100644 index 00000000..4cb39614 --- /dev/null +++ b/test/test_schedule/test_schedule.cpp @@ -0,0 +1,56 @@ +#include +#include + +#include "test_schedule.h" + +#include "globals.h" + +void two_second_blink() +{ + // NOTE!!! Wait for >2 secs + // if board doesn't support software reset via Serial.DTR/RTS + + pinMode(LED_BUILTIN, OUTPUT); + digitalWrite(LED_BUILTIN, HIGH); + delay(667); + digitalWrite(LED_BUILTIN, LOW); + delay(667); + digitalWrite(LED_BUILTIN, HIGH); + delay(667); + digitalWrite(LED_BUILTIN, LOW); +} + +void do_tests() +{ + test_status_initial_off(); + test_status_off_to_pending(); + test_status_pending_to_running(); + test_status_running_to_pending(); + test_status_running_to_off(); + + test_accuracy_timeout(); + test_accuracy_duration(); +} + +void setup() +{ + initBoard(); // Not using initialiseAll() as it will cause memory overflow + + two_second_blink(); // Very important line + + UNITY_BEGIN(); // start unit testing + + do_tests(); + + UNITY_END(); // stop unit testing + + pinMode(LED_BUILTIN, OUTPUT); +} + +void loop() +{ + digitalWrite(LED_BUILTIN, HIGH); + delay(250); + digitalWrite(LED_BUILTIN, LOW); + delay(250); +} \ No newline at end of file diff --git a/test/test_schedule/test_schedule.h b/test/test_schedule/test_schedule.h new file mode 100644 index 00000000..9c223e82 --- /dev/null +++ b/test/test_schedule/test_schedule.h @@ -0,0 +1,13 @@ +#if !defined(__TEST_SCHEDULE_H__) +#define __TEST_SCHEDULE_H__ + +void test_status_initial_off(void); +void test_status_off_to_pending(void); +void test_status_pending_to_running(void); +void test_status_running_to_off(void); +void test_status_running_to_pending(void); + +void test_accuracy_timeout(void); +void test_accuracy_duration(void); + +#endif // __TEST_SCHEDULE_H__ \ No newline at end of file diff --git a/test/test_schedule/test_status_initial_off.cpp b/test/test_schedule/test_status_initial_off.cpp new file mode 100644 index 00000000..53f98aea --- /dev/null +++ b/test/test_schedule/test_status_initial_off.cpp @@ -0,0 +1,123 @@ + +#include +#include + +#include "scheduler.h" + +void test_status_initial_off_inj1(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule1.Status); +} + +void test_status_initial_off_inj2(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule2.Status); +} + +void test_status_initial_off_inj3(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule3.Status); +} + +void test_status_initial_off_inj4(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule4.Status); +} + +void test_status_initial_off_inj5(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule5.Status); +} + +void test_status_initial_off_inj6(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule6.Status); +} + +void test_status_initial_off_inj7(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule7.Status); +} + +void test_status_initial_off_inj8(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, fuelSchedule8.Status); +} + + +void test_status_initial_off_ign1(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule1.Status); +} + +void test_status_initial_off_ign2(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule2.Status); +} + +void test_status_initial_off_ign3(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule3.Status); +} + +void test_status_initial_off_ign4(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule4.Status); +} + +void test_status_initial_off_ign5(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule5.Status); +} + +void test_status_initial_off_ign6(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule6.Status); +} + +void test_status_initial_off_ign7(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule7.Status); +} + +void test_status_initial_off_ign8(void) +{ + initialiseSchedulers(); + TEST_ASSERT_EQUAL(OFF, ignitionSchedule8.Status); +} + +void test_status_initial_off(void) +{ + RUN_TEST(test_status_initial_off_inj1); + RUN_TEST(test_status_initial_off_inj2); + RUN_TEST(test_status_initial_off_inj3); + RUN_TEST(test_status_initial_off_inj4); + RUN_TEST(test_status_initial_off_inj5); + RUN_TEST(test_status_initial_off_inj6); + RUN_TEST(test_status_initial_off_inj7); + RUN_TEST(test_status_initial_off_inj8); + + RUN_TEST(test_status_initial_off_ign1); + RUN_TEST(test_status_initial_off_ign2); + RUN_TEST(test_status_initial_off_ign3); + RUN_TEST(test_status_initial_off_ign4); + RUN_TEST(test_status_initial_off_ign5); + RUN_TEST(test_status_initial_off_ign6); + RUN_TEST(test_status_initial_off_ign7); + RUN_TEST(test_status_initial_off_ign8); +} \ No newline at end of file diff --git a/test/test_schedule/test_status_off_to_pending.cpp b/test/test_schedule/test_status_off_to_pending.cpp new file mode 100644 index 00000000..4058d9cc --- /dev/null +++ b/test/test_schedule/test_status_off_to_pending.cpp @@ -0,0 +1,160 @@ + +#include +#include + +#include "scheduler.h" + +#define TIMEOUT 1000 +#define DURATION 1000 + +static void emptyCallback(void) { } + +void test_status_off_to_pending_inj1(void) +{ + initialiseSchedulers(); + setFuelSchedule1(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule1.Status); +} + +void test_status_off_to_pending_inj2(void) +{ + initialiseSchedulers(); + setFuelSchedule2(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule2.Status); +} + +void test_status_off_to_pending_inj3(void) +{ + initialiseSchedulers(); + setFuelSchedule3(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule3.Status); +} + +void test_status_off_to_pending_inj4(void) +{ + initialiseSchedulers(); + setFuelSchedule4(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule4.Status); +} + +void test_status_off_to_pending_inj5(void) +{ +#if INJ_CHANNELS >= 5 + initialiseSchedulers(); + setFuelSchedule5(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule5.Status); +#endif +} + +void test_status_off_to_pending_inj6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setFuelSchedule6(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule6.Status); +#endif +} + +void test_status_off_to_pending_inj7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setFuelSchedule7(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule7.Status); +#endif +} + +void test_status_off_to_pending_inj8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setFuelSchedule8(TIMEOUT, DURATION); + TEST_ASSERT_EQUAL(PENDING, fuelSchedule8.Status); +#endif +} + + +void test_status_off_to_pending_ign1(void) +{ + initialiseSchedulers(); + setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule1.Status); +} + +void test_status_off_to_pending_ign2(void) +{ + initialiseSchedulers(); + setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule2.Status); +} + +void test_status_off_to_pending_ign3(void) +{ + initialiseSchedulers(); + setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule3.Status); +} + +void test_status_off_to_pending_ign4(void) +{ + initialiseSchedulers(); + setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule4.Status); +} + +void test_status_off_to_pending_ign5(void) +{ +#if IGN_CHANNELS >= 5 + initialiseSchedulers(); + setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule5.Status); +#endif +} + +void test_status_off_to_pending_ign6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule6.Status); +#endif +} + +void test_status_off_to_pending_ign7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule7.Status); +#endif +} + +void test_status_off_to_pending_ign8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback); + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule8.Status); +#endif +} + +void test_status_off_to_pending(void) +{ + RUN_TEST(test_status_off_to_pending_inj1); + RUN_TEST(test_status_off_to_pending_inj2); + RUN_TEST(test_status_off_to_pending_inj3); + RUN_TEST(test_status_off_to_pending_inj4); + RUN_TEST(test_status_off_to_pending_inj5); + RUN_TEST(test_status_off_to_pending_inj6); + RUN_TEST(test_status_off_to_pending_inj7); + RUN_TEST(test_status_off_to_pending_inj8); + + RUN_TEST(test_status_off_to_pending_ign1); + RUN_TEST(test_status_off_to_pending_ign2); + RUN_TEST(test_status_off_to_pending_ign3); + RUN_TEST(test_status_off_to_pending_ign4); + RUN_TEST(test_status_off_to_pending_ign5); + RUN_TEST(test_status_off_to_pending_ign6); + RUN_TEST(test_status_off_to_pending_ign7); + RUN_TEST(test_status_off_to_pending_ign8); +} diff --git a/test/test_schedule/test_status_pending_to_running.cpp b/test/test_schedule/test_status_pending_to_running.cpp new file mode 100644 index 00000000..6dedb78e --- /dev/null +++ b/test/test_schedule/test_status_pending_to_running.cpp @@ -0,0 +1,176 @@ + +#include +#include + +#include "scheduler.h" + +#define TIMEOUT 1000 +#define DURATION 1000 + +static void emptyCallback(void) { } + +void test_status_pending_to_running_inj1(void) +{ + initialiseSchedulers(); + setFuelSchedule1(TIMEOUT, DURATION); + while(fuelSchedule1.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule1.Status); +} + +void test_status_pending_to_running_inj2(void) +{ + initialiseSchedulers(); + setFuelSchedule2(TIMEOUT, DURATION); + while(fuelSchedule2.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule2.Status); +} + +void test_status_pending_to_running_inj3(void) +{ + initialiseSchedulers(); + setFuelSchedule3(TIMEOUT, DURATION); + while(fuelSchedule3.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule3.Status); +} + +void test_status_pending_to_running_inj4(void) +{ + initialiseSchedulers(); + setFuelSchedule4(TIMEOUT, DURATION); + while(fuelSchedule4.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule4.Status); +} + +void test_status_pending_to_running_inj5(void) +{ +#if INJ_CHANNELS >= 5 + initialiseSchedulers(); + setFuelSchedule5(TIMEOUT, DURATION); + while(fuelSchedule5.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule5.Status); +#endif +} + +void test_status_pending_to_running_inj6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setFuelSchedule6(TIMEOUT, DURATION); + while(fuelSchedule6.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule6.Status); +#endif +} + +void test_status_pending_to_running_inj7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setFuelSchedule7(TIMEOUT, DURATION); + while(fuelSchedule7.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule7.Status); +#endif +} + +void test_status_pending_to_running_inj8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setFuelSchedule8(TIMEOUT, DURATION); + while(fuelSchedule8.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, fuelSchedule8.Status); +#endif +} + + +void test_status_pending_to_running_ign1(void) +{ + initialiseSchedulers(); + setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule1.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule1.Status); +} + +void test_status_pending_to_running_ign2(void) +{ + initialiseSchedulers(); + setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule2.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule2.Status); +} + +void test_status_pending_to_running_ign3(void) +{ + initialiseSchedulers(); + setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule3.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule3.Status); +} + +void test_status_pending_to_running_ign4(void) +{ + initialiseSchedulers(); + setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule4.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule4.Status); +} + +void test_status_pending_to_running_ign5(void) +{ +#if IGN_CHANNELS >= 5 + initialiseSchedulers(); + setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule5.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule5.Status); +#endif +} + +void test_status_pending_to_running_ign6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule6.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule6.Status); +#endif +} + +void test_status_pending_to_running_ign7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule7.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule7.Status); +#endif +} + +void test_status_pending_to_running_ign8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule8.Status == PENDING) /*Wait*/ ; + TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule8.Status); +#endif +} + +void test_status_pending_to_running(void) +{ + RUN_TEST(test_status_pending_to_running_inj1); + RUN_TEST(test_status_pending_to_running_inj2); + RUN_TEST(test_status_pending_to_running_inj3); + RUN_TEST(test_status_pending_to_running_inj4); + RUN_TEST(test_status_pending_to_running_inj5); + RUN_TEST(test_status_pending_to_running_inj6); + RUN_TEST(test_status_pending_to_running_inj7); + RUN_TEST(test_status_pending_to_running_inj8); + + RUN_TEST(test_status_pending_to_running_ign1); + RUN_TEST(test_status_pending_to_running_ign2); + RUN_TEST(test_status_pending_to_running_ign3); + RUN_TEST(test_status_pending_to_running_ign4); + RUN_TEST(test_status_pending_to_running_ign5); + RUN_TEST(test_status_pending_to_running_ign6); + RUN_TEST(test_status_pending_to_running_ign7); + RUN_TEST(test_status_pending_to_running_ign8); +} diff --git a/test/test_schedule/test_status_running_to_off.cpp b/test/test_schedule/test_status_running_to_off.cpp new file mode 100644 index 00000000..fb9c61ac --- /dev/null +++ b/test/test_schedule/test_status_running_to_off.cpp @@ -0,0 +1,176 @@ + +#include +#include + +#include "scheduler.h" + +#define TIMEOUT 1000 +#define DURATION 1000 + +static void emptyCallback(void) { } + +void test_status_running_to_off_inj1(void) +{ + initialiseSchedulers(); + setFuelSchedule1(TIMEOUT, DURATION); + while( (fuelSchedule1.Status == PENDING) || (fuelSchedule1.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule1.Status); +} + +void test_status_running_to_off_inj2(void) +{ + initialiseSchedulers(); + setFuelSchedule2(TIMEOUT, DURATION); + while( (fuelSchedule2.Status == PENDING) || (fuelSchedule2.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule2.Status); +} + +void test_status_running_to_off_inj3(void) +{ + initialiseSchedulers(); + setFuelSchedule3(TIMEOUT, DURATION); + while( (fuelSchedule3.Status == PENDING) || (fuelSchedule3.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule3.Status); +} + +void test_status_running_to_off_inj4(void) +{ + initialiseSchedulers(); + setFuelSchedule4(TIMEOUT, DURATION); + while( (fuelSchedule4.Status == PENDING) || (fuelSchedule4.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule4.Status); +} + +void test_status_running_to_off_inj5(void) +{ +#if INJ_CHANNELS >= 5 + initialiseSchedulers(); + setFuelSchedule5(TIMEOUT, DURATION); + while( (fuelSchedule5.Status == PENDING) || (fuelSchedule5.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule5.Status); +#endif +} + +void test_status_running_to_off_inj6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setFuelSchedule6(TIMEOUT, DURATION); + while( (fuelSchedule6.Status == PENDING) || (fuelSchedule6.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule6.Status); +#endif +} + +void test_status_running_to_off_inj7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setFuelSchedule7(TIMEOUT, DURATION); + while( (fuelSchedule7.Status == PENDING) || (fuelSchedule7.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule7.Status); +#endif +} + +void test_status_running_to_off_inj8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setFuelSchedule8(TIMEOUT, DURATION); + while( (fuelSchedule8.Status == PENDING) || (fuelSchedule8.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, fuelSchedule8.Status); +#endif +} + + +void test_status_running_to_off_ign1(void) +{ + initialiseSchedulers(); + setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule1.Status == PENDING) || (ignitionSchedule1.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule1.Status); +} + +void test_status_running_to_off_ign2(void) +{ + initialiseSchedulers(); + setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule2.Status == PENDING) || (ignitionSchedule2.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule2.Status); +} + +void test_status_running_to_off_ign3(void) +{ + initialiseSchedulers(); + setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule3.Status == PENDING) || (ignitionSchedule3.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule3.Status); +} + +void test_status_running_to_off_ign4(void) +{ + initialiseSchedulers(); + setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule4.Status == PENDING) || (ignitionSchedule4.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule4.Status); +} + +void test_status_running_to_off_ign5(void) +{ +#if IGN_CHANNELS >= 5 + initialiseSchedulers(); + setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule5.Status == PENDING) || (ignitionSchedule5.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule5.Status); +#endif +} + +void test_status_running_to_off_ign6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule6.Status == PENDING) || (ignitionSchedule6.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule6.Status); +#endif +} + +void test_status_running_to_off_ign7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule7.Status == PENDING) || (ignitionSchedule7.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule7.Status); +#endif +} + +void test_status_running_to_off_ign8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while( (ignitionSchedule8.Status == PENDING) || (ignitionSchedule8.Status == RUNNING) ) /*Wait*/ ; + TEST_ASSERT_EQUAL(OFF, ignitionSchedule8.Status); +#endif +} + +void test_status_running_to_off(void) +{ + RUN_TEST(test_status_running_to_off_inj1); + RUN_TEST(test_status_running_to_off_inj2); + RUN_TEST(test_status_running_to_off_inj3); + RUN_TEST(test_status_running_to_off_inj4); + RUN_TEST(test_status_running_to_off_inj5); + RUN_TEST(test_status_running_to_off_inj6); + RUN_TEST(test_status_running_to_off_inj7); + RUN_TEST(test_status_running_to_off_inj8); + + RUN_TEST(test_status_running_to_off_ign1); + RUN_TEST(test_status_running_to_off_ign2); + RUN_TEST(test_status_running_to_off_ign3); + RUN_TEST(test_status_running_to_off_ign4); + RUN_TEST(test_status_running_to_off_ign5); + RUN_TEST(test_status_running_to_off_ign6); + RUN_TEST(test_status_running_to_off_ign7); + RUN_TEST(test_status_running_to_off_ign8); +} diff --git a/test/test_schedule/test_status_running_to_pending.cpp b/test/test_schedule/test_status_running_to_pending.cpp new file mode 100644 index 00000000..b712fed5 --- /dev/null +++ b/test/test_schedule/test_status_running_to_pending.cpp @@ -0,0 +1,208 @@ + +#include +#include + +#include "scheduler.h" + +#define TIMEOUT 1000 +#define DURATION 1000 + +static void emptyCallback(void) { } + +void test_status_running_to_pending_inj1(void) +{ + initialiseSchedulers(); + setFuelSchedule1(TIMEOUT, DURATION); + while(fuelSchedule1.Status == PENDING) /*Wait*/ ; + setFuelSchedule1(2*TIMEOUT, DURATION); + while(fuelSchedule1.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule1.Status); +} + +void test_status_running_to_pending_inj2(void) +{ + initialiseSchedulers(); + setFuelSchedule2(TIMEOUT, DURATION); + while(fuelSchedule2.Status == PENDING) /*Wait*/ ; + setFuelSchedule2(2*TIMEOUT, DURATION); + while(fuelSchedule2.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule2.Status); +} + +void test_status_running_to_pending_inj3(void) +{ + initialiseSchedulers(); + setFuelSchedule3(TIMEOUT, DURATION); + while(fuelSchedule3.Status == PENDING) /*Wait*/ ; + setFuelSchedule3(2*TIMEOUT, DURATION); + while(fuelSchedule3.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule3.Status); +} + +void test_status_running_to_pending_inj4(void) +{ + initialiseSchedulers(); + setFuelSchedule4(TIMEOUT, DURATION); + while(fuelSchedule4.Status == PENDING) /*Wait*/ ; + setFuelSchedule4(2*TIMEOUT, DURATION); + while(fuelSchedule4.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule4.Status); +} + +void test_status_running_to_pending_inj5(void) +{ +#if INJ_CHANNELS >= 5 + initialiseSchedulers(); + setFuelSchedule5(TIMEOUT, DURATION); + while(fuelSchedule5.Status == PENDING) /*Wait*/ ; + setFuelSchedule5(2*TIMEOUT, DURATION); + while(fuelSchedule5.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule5.Status); +#endif +} + +void test_status_running_to_pending_inj6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setFuelSchedule6(TIMEOUT, DURATION); + while(fuelSchedule6.Status == PENDING) /*Wait*/ ; + setFuelSchedule6(2*TIMEOUT, DURATION); + while(fuelSchedule6.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule6.Status); +#endif +} + +void test_status_running_to_pending_inj7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setFuelSchedule7(TIMEOUT, DURATION); + while(fuelSchedule7.Status == PENDING) /*Wait*/ ; + setFuelSchedule7(2*TIMEOUT, DURATION); + while(fuelSchedule7.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule7.Status); +#endif +} + +void test_status_running_to_pending_inj8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setFuelSchedule8(TIMEOUT, DURATION); + while(fuelSchedule8.Status == PENDING) /*Wait*/ ; + setFuelSchedule8(2*TIMEOUT, DURATION); + while(fuelSchedule8.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, fuelSchedule8.Status); +#endif +} + + +void test_status_running_to_pending_ign1(void) +{ + initialiseSchedulers(); + setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule1.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule1(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule1.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule1.Status); +} + +void test_status_running_to_pending_ign2(void) +{ + initialiseSchedulers(); + setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule2.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule2(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule2.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule2.Status); +} + +void test_status_running_to_pending_ign3(void) +{ + initialiseSchedulers(); + setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule3.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule3(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule3.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule3.Status); +} + +void test_status_running_to_pending_ign4(void) +{ + initialiseSchedulers(); + setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule4.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule4(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule4.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule4.Status); +} + +void test_status_running_to_pending_ign5(void) +{ +#if IGN_CHANNELS >= 5 + initialiseSchedulers(); + setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule5.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule5(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule5.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule5.Status); +#endif +} + +void test_status_running_to_pending_ign6(void) +{ +#if INJ_CHANNELS >= 6 + initialiseSchedulers(); + setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule6.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule6(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule6.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule6.Status); +#endif +} + +void test_status_running_to_pending_ign7(void) +{ +#if INJ_CHANNELS >= 7 + initialiseSchedulers(); + setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule7.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule7(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule7.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule7.Status); +#endif +} + +void test_status_running_to_pending_ign8(void) +{ +#if INJ_CHANNELS >= 8 + initialiseSchedulers(); + setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule8.Status == PENDING) /*Wait*/ ; + setIgnitionSchedule8(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback); + while(ignitionSchedule8.Status == RUNNING) /*Wait*/ ; + TEST_ASSERT_EQUAL(PENDING, ignitionSchedule8.Status); +#endif +} + +void test_status_running_to_pending(void) +{ + RUN_TEST(test_status_running_to_pending_inj1); + RUN_TEST(test_status_running_to_pending_inj2); + RUN_TEST(test_status_running_to_pending_inj3); + RUN_TEST(test_status_running_to_pending_inj4); + RUN_TEST(test_status_running_to_pending_inj5); + RUN_TEST(test_status_running_to_pending_inj6); + RUN_TEST(test_status_running_to_pending_inj7); + RUN_TEST(test_status_running_to_pending_inj8); + + RUN_TEST(test_status_running_to_pending_ign1); + RUN_TEST(test_status_running_to_pending_ign2); + RUN_TEST(test_status_running_to_pending_ign3); + RUN_TEST(test_status_running_to_pending_ign4); + RUN_TEST(test_status_running_to_pending_ign5); + RUN_TEST(test_status_running_to_pending_ign6); + RUN_TEST(test_status_running_to_pending_ign7); + RUN_TEST(test_status_running_to_pending_ign8); +} diff --git a/test/tests_schedules.cpp b/test/tests_schedules.cpp deleted file mode 100644 index 680400fa..00000000 --- a/test/tests_schedules.cpp +++ /dev/null @@ -1,202 +0,0 @@ -#include -#include -#include -#include "tests_schedules.h" -#include "scheduler.h" - - -/* **************************************************************************** - * Static functions - * ***************************************************************************/ - -static void test_schedule_fuel_time(void); -static void test_schedule_fuel_pending(void); -static void test_schedule_ignition_time(void); -static void test_schedule_ignition_pending(void); - -static uint32_t beginTime, endTime; -static void beginCallback(void) { beginTime = micros(); } -static void endCallback(void) { endTime = micros(); } - - -/* **************************************************************************** - * Global variables - * ***************************************************************************/ - -static FuelSchedule* fuelSchedule[] = { - &fuelSchedule1, - &fuelSchedule2, - &fuelSchedule3, - &fuelSchedule4, - &fuelSchedule5, - &fuelSchedule6, - &fuelSchedule7, - &fuelSchedule8, -}; - -static Schedule* ignitionSchedule[] = { - &ignitionSchedule1, - &ignitionSchedule2, - &ignitionSchedule3, - &ignitionSchedule4, - &ignitionSchedule5, - &ignitionSchedule6, - &ignitionSchedule7, - &ignitionSchedule8, -}; - -void (*setFuelSchedule[])(unsigned long, unsigned long) = { - setFuelSchedule1, - setFuelSchedule2, - setFuelSchedule3, - setFuelSchedule4, -#if INJ_CHANNELS >= 5 - setFuelSchedule5, -#endif -#if INJ_CHANNELS >= 6 - setFuelSchedule6, -#endif -#if INJ_CHANNELS >= 7 - setFuelSchedule7, -#endif -#if INJ_CHANNELS >= 8 - setFuelSchedule8, -#endif -}; - -void (*setIgnitionSchedule[])(void (*)(), unsigned long, unsigned long, void (*)()) = { - setIgnitionSchedule1, - setIgnitionSchedule2, - setIgnitionSchedule3, - setIgnitionSchedule4, -#if IGN_CHANNELS >= 5 - setIgnitionSchedule5, -#endif -#if IGN_CHANNELS >= 6 - setIgnitionSchedule6, -#endif -#if IGN_CHANNELS >= 7 - setIgnitionSchedule7, -#endif -#if IGN_CHANNELS >= 8 - setIgnitionSchedule8, -#endif -}; - - -/* **************************************************************************** - * Test Main - * ***************************************************************************/ - -void testSchedules() -{ - RUN_TEST(test_schedule_fuel_time); - RUN_TEST(test_schedule_fuel_pending); - RUN_TEST(test_schedule_ignition_time); - RUN_TEST(test_schedule_ignition_pending); -} - - -/* **************************************************************************** - * Test Functions - * ***************************************************************************/ - -static void test_schedule_fuel_time(void) -{ - TEST_ASSERT_EQUAL(true, initialisationComplete); - - for(int i = 0; i < INJ_CHANNELS; i++) - { - TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status); - - uint32_t time1 = micros(); - setFuelSchedule[i](1000, 1000); - TEST_ASSERT_EQUAL(PENDING, fuelSchedule[i]->Status); - - while(fuelSchedule[i]->Status == PENDING); // wait - uint32_t time2 = micros(); - TEST_ASSERT_EQUAL(RUNNING, fuelSchedule[i]->Status); - - while(fuelSchedule[i]->Status == RUNNING); // wait - uint32_t time3 = micros(); - TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status); - - TEST_ASSERT_EQUAL(1016, time2 - time1); - TEST_ASSERT_EQUAL(1008, time3 - time2); - } -} - -static void test_schedule_fuel_pending(void) -{ - TEST_ASSERT_EQUAL(true, initialisationComplete); - - for(int i = 0; i < INJ_CHANNELS; i++) - { - TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status); - - setFuelSchedule[i](1000, 1000); - TEST_ASSERT_EQUAL(PENDING, fuelSchedule[i]->Status); - - while(fuelSchedule[i]->Status == PENDING); // wait - TEST_ASSERT_EQUAL(RUNNING, fuelSchedule[i]->Status); - setFuelSchedule[i](1500, 500); // Once running, set another schedule - - while(fuelSchedule[i]->Status == RUNNING); // wait - TEST_ASSERT_EQUAL(PENDING, fuelSchedule[i]->Status); - - while(fuelSchedule[i]->Status == PENDING); // wait - TEST_ASSERT_EQUAL(RUNNING, fuelSchedule[i]->Status); - - while(fuelSchedule[i]->Status == RUNNING); // wait - TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status); - } -} - -static void test_schedule_ignition_time(void) -{ - TEST_ASSERT_EQUAL(true, initialisationComplete); - - for(int i = 0; i < IGN_CHANNELS; i++) - { - TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status); - - uint32_t time1 = micros(); - setIgnitionSchedule[i](beginCallback, 1000, 1000, endCallback); - TEST_ASSERT_EQUAL(PENDING, ignitionSchedule[i]->Status); - - while(ignitionSchedule[i]->Status == PENDING); // wait - TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule[i]->Status); - - while(ignitionSchedule[i]->Status == RUNNING); // wait - TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status); - - TEST_ASSERT_EQUAL(1012, beginTime - time1); - TEST_ASSERT_EQUAL(1012, endTime - beginTime); - } -} - -static void test_schedule_ignition_pending(void) -{ - TEST_ASSERT_EQUAL(true, initialisationComplete); - - for(int i = 0; i < IGN_CHANNELS; i++) - { - TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status); - - setIgnitionSchedule[i](beginCallback, 1000, 1000, endCallback); - TEST_ASSERT_EQUAL(PENDING, ignitionSchedule[i]->Status); - - while(ignitionSchedule[i]->Status == PENDING); // wait - TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule[i]->Status); - setIgnitionSchedule[i](beginCallback, 1500, 500, endCallback); // Once running, set another schedule - - while(ignitionSchedule[i]->Status == RUNNING); // wait - TEST_ASSERT_EQUAL(PENDING, ignitionSchedule[i]->Status); - - while(ignitionSchedule[i]->Status == PENDING); // wait - TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule[i]->Status); - - while(ignitionSchedule[i]->Status == RUNNING); // wait - TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status); - } -} \ No newline at end of file diff --git a/test/tests_schedules.h b/test/tests_schedules.h deleted file mode 100644 index fe8c0519..00000000 --- a/test/tests_schedules.h +++ /dev/null @@ -1 +0,0 @@ -void testSchedules(); \ No newline at end of file