main.cpp

00001 #include "mbed_events.h"
00002 #include "mbed.h"
00003 #include "rtos.h"
00004 #include "greentea-client/test_env.h"
00005 #include "unity.h"
00006 #include "utest.h"
00007 
00008 using namespace utest::v1;
00009 
00010 
00011 // flag for called
00012 volatile bool touched = false;
00013 
00014 // static functions
00015 void func5(int a0, int a1, int a2, int a3, int a4) { 
00016     touched = true;
00017     TEST_ASSERT_EQUAL(a0 | a1 | a2 | a3 | a4, 0x1f);
00018 }
00019 
00020 void func4(int a0, int a1, int a2, int a3) {
00021     touched = true;
00022     TEST_ASSERT_EQUAL(a0 | a1 | a2 | a3, 0xf); 
00023 }
00024 
00025 void func3(int a0, int a1, int a2) {
00026     touched = true;
00027     TEST_ASSERT_EQUAL(a0 | a1 | a2, 0x7);
00028 }
00029 
00030 void func2(int a0, int a1) {
00031     touched = true;
00032     TEST_ASSERT_EQUAL(a0 | a1, 0x3);
00033 }
00034 
00035 void func1(int a0) {
00036     touched = true;
00037     TEST_ASSERT_EQUAL(a0, 0x1);
00038 }
00039 
00040 void func0() {
00041     touched = true;
00042 }
00043 
00044 #define SIMPLE_POSTS_TEST(i, ...)                           \
00045 void simple_posts_test##i() {                               \
00046     EventQueue queue;                                       \
00047                                                             \
00048     touched = false;                                        \
00049     queue.call(func##i,##__VA_ARGS__);                      \
00050     queue.dispatch(0);                                      \
00051     TEST_ASSERT(touched);                                   \
00052                                                             \
00053     touched = false;                                        \
00054     queue.call_in(1, func##i,##__VA_ARGS__);                \
00055     queue.dispatch(2);                                      \
00056     TEST_ASSERT(touched);                                   \
00057                                                             \
00058     touched = false;                                        \
00059     queue.call_every(1, func##i,##__VA_ARGS__);             \
00060     queue.dispatch(2);                                      \
00061     TEST_ASSERT(touched);                                   \
00062 }
00063 
00064 SIMPLE_POSTS_TEST(5, 0x01, 0x02, 0x04, 0x08, 0x010)
00065 SIMPLE_POSTS_TEST(4, 0x01, 0x02, 0x04, 0x08)
00066 SIMPLE_POSTS_TEST(3, 0x01, 0x02, 0x04)
00067 SIMPLE_POSTS_TEST(2, 0x01, 0x02)
00068 SIMPLE_POSTS_TEST(1, 0x01)
00069 SIMPLE_POSTS_TEST(0)
00070 
00071 
00072 void time_func(Timer *t, int ms) {
00073     TEST_ASSERT_INT_WITHIN(2, ms, t->read_ms());
00074     t->reset();
00075 }
00076 
00077 template <int N>
00078 void call_in_test() {
00079     Timer tickers[N];
00080 
00081     EventQueue queue;
00082 
00083     for (int i = 0; i < N; i++) {
00084         tickers[i].start();
00085         queue.call_in((i+1)*100, time_func, &tickers[i], (i+1)*100);
00086     }
00087 
00088     queue.dispatch(N*100);
00089 }
00090 
00091 template <int N>
00092 void call_every_test() {
00093     Timer tickers[N];
00094 
00095     EventQueue queue;
00096 
00097     for (int i = 0; i < N; i++) {
00098         tickers[i].start();
00099         queue.call_every((i+1)*100, time_func, &tickers[i], (i+1)*100);
00100     }
00101 
00102     queue.dispatch(N*100);
00103 }
00104 
00105 void allocate_failure_test() {
00106     EventQueue queue;
00107     int id;
00108 
00109     for (int i = 0; i < 100; i++) {
00110         id = queue.call((void (*)())0);
00111     }
00112 
00113     TEST_ASSERT(!id);
00114 }
00115 
00116 void no() {
00117     TEST_ASSERT(false);
00118 }
00119 
00120 template <int N>
00121 void cancel_test1() {
00122     EventQueue queue;
00123 
00124     int ids[N];
00125 
00126     for (int i = 0; i < N; i++) {
00127         ids[i] = queue.call_in(1000, no);
00128     }
00129 
00130     for (int i = N-1; i >= 0; i--) {
00131         queue.cancel(ids[i]);
00132     }
00133 
00134     queue.dispatch(0);
00135 }
00136 
00137 
00138 // Testing the dynamic arguments to the event class
00139 unsigned counter = 0;
00140 
00141 void count5(unsigned a0, unsigned a1, unsigned a2, unsigned a3, unsigned a5) {
00142     counter += a0 + a1 + a2 + a3 + a5;
00143 }
00144 
00145 void count4(unsigned a0, unsigned a1, unsigned a2, unsigned a3) {
00146     counter += a0 + a1 + a2 + a3;
00147 }
00148 
00149 void count3(unsigned a0, unsigned a1, unsigned a2) {
00150     counter += a0 + a1 + a2;
00151 }
00152 
00153 void count2(unsigned a0, unsigned a1) {
00154     counter += a0 + a1;
00155 }
00156 
00157 void count1(unsigned a0) {
00158     counter += a0;
00159 }
00160 
00161 void count0() {
00162     counter += 0;
00163 }
00164 
00165 void event_class_test() {
00166     counter = 0;
00167     EventQueue queue(2048);
00168 
00169     Event<void(int, int, int, int, int)> e5(&queue, count5);
00170     Event<void(int, int, int, int)> e4(&queue, count5, 1);
00171     Event<void(int, int, int)> e3(&queue, count5, 1, 1);
00172     Event<void(int, int)> e2(&queue, count5, 1, 1, 1);
00173     Event<void(int)> e1(&queue, count5, 1, 1, 1, 1);
00174     Event<void()> e0(&queue, count5, 1, 1, 1, 1, 1);
00175 
00176     e5.post(1, 1, 1, 1, 1);
00177     e4.post(1, 1, 1, 1);
00178     e3.post(1, 1, 1);
00179     e2.post(1, 1);
00180     e1.post(1);
00181     e0.post();
00182 
00183     queue.dispatch(0);
00184 
00185     TEST_ASSERT_EQUAL(counter, 30);
00186 }
00187 
00188 void event_class_helper_test() {
00189     counter = 0;
00190     EventQueue queue(2048);
00191 
00192     Event<void()> e5 = queue.event(count5, 1, 1, 1, 1, 1);
00193     Event<void()> e4 = queue.event(count4, 1, 1, 1, 1);
00194     Event<void()> e3 = queue.event(count3, 1, 1, 1);
00195     Event<void()> e2 = queue.event(count2, 1, 1);
00196     Event<void()> e1 = queue.event(count1, 1);
00197     Event<void()> e0 = queue.event(count0);
00198 
00199     e5.post();
00200     e4.post();
00201     e3.post();
00202     e2.post();
00203     e1.post();
00204     e0.post();
00205 
00206     queue.dispatch(0);
00207 
00208     TEST_ASSERT_EQUAL(counter, 15);
00209 }
00210 
00211 void event_inference_test() {
00212     counter = 0;
00213     EventQueue queue (2048);
00214 
00215     queue.event(count5, 1, 1, 1, 1, 1).post();
00216     queue.event(count5, 1, 1, 1, 1).post(1);
00217     queue.event(count5, 1, 1, 1).post(1, 1);
00218     queue.event(count5, 1, 1).post(1, 1, 1);
00219     queue.event(count5, 1).post(1, 1, 1, 1);
00220     queue.event(count5).post(1, 1, 1, 1, 1);
00221 
00222     queue.dispatch(0);
00223 
00224     TEST_ASSERT_EQUAL(counter, 30);
00225 }
00226 
00227 
00228 // Test setup
00229 utest::v1::status_t  test_setup(const size_t number_of_cases) {
00230     GREENTEA_SETUP(20, "default_auto");
00231     return verbose_test_setup_handler(number_of_cases);
00232 }
00233 
00234 const Case cases[] = {
00235     Case("Testing calls with 5 args", simple_posts_test5),
00236     Case("Testing calls with 4 args", simple_posts_test4),
00237     Case("Testing calls with 3 args", simple_posts_test3),
00238     Case("Testing calls with 2 args", simple_posts_test2),
00239     Case("Testing calls with 1 args", simple_posts_test1),
00240     Case("Testing calls with 0 args", simple_posts_test0),
00241 
00242     Case("Testing call_in",    call_in_test<20>),
00243     Case("Testing call_every", call_every_test<20>),
00244 
00245     Case("Testing allocate failure", allocate_failure_test),
00246 
00247     Case("Testing event cancel 1", cancel_test1<20>),
00248     Case("Testing the event class", event_class_test),
00249     Case("Testing the event class helpers", event_class_helper_test),
00250     Case("Testing the event inference", event_inference_test),
00251 };
00252 
00253 Specification specification(test_setup, cases);
00254 
00255 int main() {
00256     return !Harness::run(specification);
00257 }
00258