EL4121 Embedded System / mbed-os

mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

events/equeue/tests/tests.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /*
be_bryan 0:b74591d5ab33 2 * Testing framework for the events library
be_bryan 0:b74591d5ab33 3 *
be_bryan 0:b74591d5ab33 4 * Copyright (c) 2016 Christopher Haster
be_bryan 0:b74591d5ab33 5 *
be_bryan 0:b74591d5ab33 6 * Licensed under the Apache License, Version 2.0 (the "License");
be_bryan 0:b74591d5ab33 7 * you may not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 8 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 9 *
be_bryan 0:b74591d5ab33 10 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 11 *
be_bryan 0:b74591d5ab33 12 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 13 * distributed under the License is distributed on an "AS IS" BASIS,
be_bryan 0:b74591d5ab33 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 15 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 16 * limitations under the License.
be_bryan 0:b74591d5ab33 17 */
be_bryan 0:b74591d5ab33 18 #include "equeue.h"
be_bryan 0:b74591d5ab33 19 #include <unistd.h>
be_bryan 0:b74591d5ab33 20 #include <stdio.h>
be_bryan 0:b74591d5ab33 21 #include <setjmp.h>
be_bryan 0:b74591d5ab33 22 #include <stdint.h>
be_bryan 0:b74591d5ab33 23 #include <stdlib.h>
be_bryan 0:b74591d5ab33 24 #include <pthread.h>
be_bryan 0:b74591d5ab33 25
be_bryan 0:b74591d5ab33 26
be_bryan 0:b74591d5ab33 27 // Testing setup
be_bryan 0:b74591d5ab33 28 static jmp_buf test_buf;
be_bryan 0:b74591d5ab33 29 static int test_line;
be_bryan 0:b74591d5ab33 30 static int test_failure;
be_bryan 0:b74591d5ab33 31
be_bryan 0:b74591d5ab33 32 #define test_assert(test) ({ \
be_bryan 0:b74591d5ab33 33 if (!(test)) { \
be_bryan 0:b74591d5ab33 34 test_line = __LINE__; \
be_bryan 0:b74591d5ab33 35 longjmp(test_buf, 1); \
be_bryan 0:b74591d5ab33 36 } \
be_bryan 0:b74591d5ab33 37 })
be_bryan 0:b74591d5ab33 38
be_bryan 0:b74591d5ab33 39 #define test_run(func, ...) ({ \
be_bryan 0:b74591d5ab33 40 printf("%s: ...", #func); \
be_bryan 0:b74591d5ab33 41 fflush(stdout); \
be_bryan 0:b74591d5ab33 42 \
be_bryan 0:b74591d5ab33 43 if (!setjmp(test_buf)) { \
be_bryan 0:b74591d5ab33 44 func(__VA_ARGS__); \
be_bryan 0:b74591d5ab33 45 printf("\r%s: \e[32mpassed\e[0m\n", #func); \
be_bryan 0:b74591d5ab33 46 } else { \
be_bryan 0:b74591d5ab33 47 printf("\r%s: \e[31mfailed\e[0m at line %d\n", #func, test_line); \
be_bryan 0:b74591d5ab33 48 test_failure = true; \
be_bryan 0:b74591d5ab33 49 } \
be_bryan 0:b74591d5ab33 50 })
be_bryan 0:b74591d5ab33 51
be_bryan 0:b74591d5ab33 52
be_bryan 0:b74591d5ab33 53 // Test functions
be_bryan 0:b74591d5ab33 54 void pass_func(void *eh) {
be_bryan 0:b74591d5ab33 55 }
be_bryan 0:b74591d5ab33 56
be_bryan 0:b74591d5ab33 57 void simple_func(void *p) {
be_bryan 0:b74591d5ab33 58 (*(int *)p)++;
be_bryan 0:b74591d5ab33 59 }
be_bryan 0:b74591d5ab33 60
be_bryan 0:b74591d5ab33 61 void sloth_func(void *p) {
be_bryan 0:b74591d5ab33 62 usleep(10000);
be_bryan 0:b74591d5ab33 63 (*(int *)p)++;
be_bryan 0:b74591d5ab33 64 }
be_bryan 0:b74591d5ab33 65
be_bryan 0:b74591d5ab33 66 struct indirect {
be_bryan 0:b74591d5ab33 67 int *touched;
be_bryan 0:b74591d5ab33 68 uint8_t buffer[7];
be_bryan 0:b74591d5ab33 69 };
be_bryan 0:b74591d5ab33 70
be_bryan 0:b74591d5ab33 71 void indirect_func(void *p) {
be_bryan 0:b74591d5ab33 72 struct indirect *i = (struct indirect*)p;
be_bryan 0:b74591d5ab33 73 (*i->touched)++;
be_bryan 0:b74591d5ab33 74 }
be_bryan 0:b74591d5ab33 75
be_bryan 0:b74591d5ab33 76 struct timing {
be_bryan 0:b74591d5ab33 77 unsigned tick;
be_bryan 0:b74591d5ab33 78 unsigned delay;
be_bryan 0:b74591d5ab33 79 };
be_bryan 0:b74591d5ab33 80
be_bryan 0:b74591d5ab33 81 void timing_func(void *p) {
be_bryan 0:b74591d5ab33 82 struct timing *timing = (struct timing*)p;
be_bryan 0:b74591d5ab33 83 unsigned tick = equeue_tick();
be_bryan 0:b74591d5ab33 84
be_bryan 0:b74591d5ab33 85 unsigned t1 = timing->delay;
be_bryan 0:b74591d5ab33 86 unsigned t2 = tick - timing->tick;
be_bryan 0:b74591d5ab33 87 test_assert(t1 > t2 - 10 && t1 < t2 + 10);
be_bryan 0:b74591d5ab33 88
be_bryan 0:b74591d5ab33 89 timing->tick = tick;
be_bryan 0:b74591d5ab33 90 }
be_bryan 0:b74591d5ab33 91
be_bryan 0:b74591d5ab33 92 struct fragment {
be_bryan 0:b74591d5ab33 93 equeue_t *q;
be_bryan 0:b74591d5ab33 94 size_t size;
be_bryan 0:b74591d5ab33 95 struct timing timing;
be_bryan 0:b74591d5ab33 96 };
be_bryan 0:b74591d5ab33 97
be_bryan 0:b74591d5ab33 98 void fragment_func(void *p) {
be_bryan 0:b74591d5ab33 99 struct fragment *fragment = (struct fragment*)p;
be_bryan 0:b74591d5ab33 100 timing_func(&fragment->timing);
be_bryan 0:b74591d5ab33 101
be_bryan 0:b74591d5ab33 102 struct fragment *nfragment = equeue_alloc(fragment->q, fragment->size);
be_bryan 0:b74591d5ab33 103 test_assert(nfragment);
be_bryan 0:b74591d5ab33 104
be_bryan 0:b74591d5ab33 105 *nfragment = *fragment;
be_bryan 0:b74591d5ab33 106 equeue_event_delay(nfragment, fragment->timing.delay);
be_bryan 0:b74591d5ab33 107
be_bryan 0:b74591d5ab33 108 int id = equeue_post(nfragment->q, fragment_func, nfragment);
be_bryan 0:b74591d5ab33 109 test_assert(id);
be_bryan 0:b74591d5ab33 110 }
be_bryan 0:b74591d5ab33 111
be_bryan 0:b74591d5ab33 112 struct cancel {
be_bryan 0:b74591d5ab33 113 equeue_t *q;
be_bryan 0:b74591d5ab33 114 int id;
be_bryan 0:b74591d5ab33 115 };
be_bryan 0:b74591d5ab33 116
be_bryan 0:b74591d5ab33 117 void cancel_func(void *p) {
be_bryan 0:b74591d5ab33 118 struct cancel *cancel = (struct cancel *)p;
be_bryan 0:b74591d5ab33 119 equeue_cancel(cancel->q, cancel->id);
be_bryan 0:b74591d5ab33 120 }
be_bryan 0:b74591d5ab33 121
be_bryan 0:b74591d5ab33 122 struct nest {
be_bryan 0:b74591d5ab33 123 equeue_t *q;
be_bryan 0:b74591d5ab33 124 void (*cb)(void *);
be_bryan 0:b74591d5ab33 125 void *data;
be_bryan 0:b74591d5ab33 126 };
be_bryan 0:b74591d5ab33 127
be_bryan 0:b74591d5ab33 128 void nest_func(void *p) {
be_bryan 0:b74591d5ab33 129 struct nest *nest = (struct nest *)p;
be_bryan 0:b74591d5ab33 130 equeue_call(nest->q, nest->cb, nest->data);
be_bryan 0:b74591d5ab33 131
be_bryan 0:b74591d5ab33 132 usleep(10000);
be_bryan 0:b74591d5ab33 133 }
be_bryan 0:b74591d5ab33 134
be_bryan 0:b74591d5ab33 135
be_bryan 0:b74591d5ab33 136 // Simple call tests
be_bryan 0:b74591d5ab33 137 void simple_call_test(void) {
be_bryan 0:b74591d5ab33 138 equeue_t q;
be_bryan 0:b74591d5ab33 139 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 140 test_assert(!err);
be_bryan 0:b74591d5ab33 141
be_bryan 0:b74591d5ab33 142 bool touched = false;
be_bryan 0:b74591d5ab33 143 equeue_call(&q, simple_func, &touched);
be_bryan 0:b74591d5ab33 144 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 145 test_assert(touched);
be_bryan 0:b74591d5ab33 146
be_bryan 0:b74591d5ab33 147 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 148 }
be_bryan 0:b74591d5ab33 149
be_bryan 0:b74591d5ab33 150 void simple_call_in_test(void) {
be_bryan 0:b74591d5ab33 151 equeue_t q;
be_bryan 0:b74591d5ab33 152 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 153 test_assert(!err);
be_bryan 0:b74591d5ab33 154
be_bryan 0:b74591d5ab33 155 bool touched = false;
be_bryan 0:b74591d5ab33 156 int id = equeue_call_in(&q, 10, simple_func, &touched);
be_bryan 0:b74591d5ab33 157 test_assert(id);
be_bryan 0:b74591d5ab33 158
be_bryan 0:b74591d5ab33 159 equeue_dispatch(&q, 15);
be_bryan 0:b74591d5ab33 160 test_assert(touched);
be_bryan 0:b74591d5ab33 161
be_bryan 0:b74591d5ab33 162 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 163 }
be_bryan 0:b74591d5ab33 164
be_bryan 0:b74591d5ab33 165 void simple_call_every_test(void) {
be_bryan 0:b74591d5ab33 166 equeue_t q;
be_bryan 0:b74591d5ab33 167 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 168 test_assert(!err);
be_bryan 0:b74591d5ab33 169
be_bryan 0:b74591d5ab33 170 bool touched = false;
be_bryan 0:b74591d5ab33 171 int id = equeue_call_every(&q, 10, simple_func, &touched);
be_bryan 0:b74591d5ab33 172 test_assert(id);
be_bryan 0:b74591d5ab33 173
be_bryan 0:b74591d5ab33 174 equeue_dispatch(&q, 15);
be_bryan 0:b74591d5ab33 175 test_assert(touched);
be_bryan 0:b74591d5ab33 176
be_bryan 0:b74591d5ab33 177 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 178 }
be_bryan 0:b74591d5ab33 179
be_bryan 0:b74591d5ab33 180 void simple_post_test(void) {
be_bryan 0:b74591d5ab33 181 equeue_t q;
be_bryan 0:b74591d5ab33 182 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 183 test_assert(!err);
be_bryan 0:b74591d5ab33 184
be_bryan 0:b74591d5ab33 185 int touched = false;
be_bryan 0:b74591d5ab33 186 struct indirect *i = equeue_alloc(&q, sizeof(struct indirect));
be_bryan 0:b74591d5ab33 187 test_assert(i);
be_bryan 0:b74591d5ab33 188
be_bryan 0:b74591d5ab33 189 i->touched = &touched;
be_bryan 0:b74591d5ab33 190 int id = equeue_post(&q, indirect_func, i);
be_bryan 0:b74591d5ab33 191 test_assert(id);
be_bryan 0:b74591d5ab33 192
be_bryan 0:b74591d5ab33 193 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 194 test_assert(*i->touched);
be_bryan 0:b74591d5ab33 195
be_bryan 0:b74591d5ab33 196 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 197 }
be_bryan 0:b74591d5ab33 198
be_bryan 0:b74591d5ab33 199 // Misc tests
be_bryan 0:b74591d5ab33 200 void destructor_test(void) {
be_bryan 0:b74591d5ab33 201 equeue_t q;
be_bryan 0:b74591d5ab33 202 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 203 test_assert(!err);
be_bryan 0:b74591d5ab33 204
be_bryan 0:b74591d5ab33 205 int touched;
be_bryan 0:b74591d5ab33 206 struct indirect *e;
be_bryan 0:b74591d5ab33 207 int ids[3];
be_bryan 0:b74591d5ab33 208
be_bryan 0:b74591d5ab33 209 touched = 0;
be_bryan 0:b74591d5ab33 210 for (int i = 0; i < 3; i++) {
be_bryan 0:b74591d5ab33 211 e = equeue_alloc(&q, sizeof(struct indirect));
be_bryan 0:b74591d5ab33 212 test_assert(e);
be_bryan 0:b74591d5ab33 213
be_bryan 0:b74591d5ab33 214 e->touched = &touched;
be_bryan 0:b74591d5ab33 215 equeue_event_dtor(e, indirect_func);
be_bryan 0:b74591d5ab33 216 int id = equeue_post(&q, pass_func, e);
be_bryan 0:b74591d5ab33 217 test_assert(id);
be_bryan 0:b74591d5ab33 218 }
be_bryan 0:b74591d5ab33 219
be_bryan 0:b74591d5ab33 220 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 221 test_assert(touched == 3);
be_bryan 0:b74591d5ab33 222
be_bryan 0:b74591d5ab33 223 touched = 0;
be_bryan 0:b74591d5ab33 224 for (int i = 0; i < 3; i++) {
be_bryan 0:b74591d5ab33 225 e = equeue_alloc(&q, sizeof(struct indirect));
be_bryan 0:b74591d5ab33 226 test_assert(e);
be_bryan 0:b74591d5ab33 227
be_bryan 0:b74591d5ab33 228 e->touched = &touched;
be_bryan 0:b74591d5ab33 229 equeue_event_dtor(e, indirect_func);
be_bryan 0:b74591d5ab33 230 ids[i] = equeue_post(&q, pass_func, e);
be_bryan 0:b74591d5ab33 231 test_assert(ids[i]);
be_bryan 0:b74591d5ab33 232 }
be_bryan 0:b74591d5ab33 233
be_bryan 0:b74591d5ab33 234 for (int i = 0; i < 3; i++) {
be_bryan 0:b74591d5ab33 235 equeue_cancel(&q, ids[i]);
be_bryan 0:b74591d5ab33 236 }
be_bryan 0:b74591d5ab33 237
be_bryan 0:b74591d5ab33 238 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 239 test_assert(touched == 3);
be_bryan 0:b74591d5ab33 240
be_bryan 0:b74591d5ab33 241 touched = 0;
be_bryan 0:b74591d5ab33 242 for (int i = 0; i < 3; i++) {
be_bryan 0:b74591d5ab33 243 e = equeue_alloc(&q, sizeof(struct indirect));
be_bryan 0:b74591d5ab33 244 test_assert(e);
be_bryan 0:b74591d5ab33 245
be_bryan 0:b74591d5ab33 246 e->touched = &touched;
be_bryan 0:b74591d5ab33 247 equeue_event_dtor(e, indirect_func);
be_bryan 0:b74591d5ab33 248 int id = equeue_post(&q, pass_func, e);
be_bryan 0:b74591d5ab33 249 test_assert(id);
be_bryan 0:b74591d5ab33 250 }
be_bryan 0:b74591d5ab33 251
be_bryan 0:b74591d5ab33 252 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 253 test_assert(touched == 3);
be_bryan 0:b74591d5ab33 254 }
be_bryan 0:b74591d5ab33 255
be_bryan 0:b74591d5ab33 256 void allocation_failure_test(void) {
be_bryan 0:b74591d5ab33 257 equeue_t q;
be_bryan 0:b74591d5ab33 258 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 259 test_assert(!err);
be_bryan 0:b74591d5ab33 260
be_bryan 0:b74591d5ab33 261 void *p = equeue_alloc(&q, 4096);
be_bryan 0:b74591d5ab33 262 test_assert(!p);
be_bryan 0:b74591d5ab33 263
be_bryan 0:b74591d5ab33 264 for (int i = 0; i < 100; i++) {
be_bryan 0:b74591d5ab33 265 p = equeue_alloc(&q, 0);
be_bryan 0:b74591d5ab33 266 }
be_bryan 0:b74591d5ab33 267 test_assert(!p);
be_bryan 0:b74591d5ab33 268
be_bryan 0:b74591d5ab33 269 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 270 }
be_bryan 0:b74591d5ab33 271
be_bryan 0:b74591d5ab33 272 void cancel_test(int N) {
be_bryan 0:b74591d5ab33 273 equeue_t q;
be_bryan 0:b74591d5ab33 274 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 275 test_assert(!err);
be_bryan 0:b74591d5ab33 276
be_bryan 0:b74591d5ab33 277 bool touched = false;
be_bryan 0:b74591d5ab33 278 int *ids = malloc(N*sizeof(int));
be_bryan 0:b74591d5ab33 279
be_bryan 0:b74591d5ab33 280 for (int i = 0; i < N; i++) {
be_bryan 0:b74591d5ab33 281 ids[i] = equeue_call(&q, simple_func, &touched);
be_bryan 0:b74591d5ab33 282 }
be_bryan 0:b74591d5ab33 283
be_bryan 0:b74591d5ab33 284 for (int i = N-1; i >= 0; i--) {
be_bryan 0:b74591d5ab33 285 equeue_cancel(&q, ids[i]);
be_bryan 0:b74591d5ab33 286 }
be_bryan 0:b74591d5ab33 287
be_bryan 0:b74591d5ab33 288 free(ids);
be_bryan 0:b74591d5ab33 289
be_bryan 0:b74591d5ab33 290 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 291 test_assert(!touched);
be_bryan 0:b74591d5ab33 292
be_bryan 0:b74591d5ab33 293 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 294 }
be_bryan 0:b74591d5ab33 295
be_bryan 0:b74591d5ab33 296 void cancel_inflight_test(void) {
be_bryan 0:b74591d5ab33 297 equeue_t q;
be_bryan 0:b74591d5ab33 298 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 299 test_assert(!err);
be_bryan 0:b74591d5ab33 300
be_bryan 0:b74591d5ab33 301 bool touched = false;
be_bryan 0:b74591d5ab33 302
be_bryan 0:b74591d5ab33 303 int id = equeue_call(&q, simple_func, &touched);
be_bryan 0:b74591d5ab33 304 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 305
be_bryan 0:b74591d5ab33 306 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 307 test_assert(!touched);
be_bryan 0:b74591d5ab33 308
be_bryan 0:b74591d5ab33 309 id = equeue_call(&q, simple_func, &touched);
be_bryan 0:b74591d5ab33 310 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 311
be_bryan 0:b74591d5ab33 312 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 313 test_assert(!touched);
be_bryan 0:b74591d5ab33 314
be_bryan 0:b74591d5ab33 315 struct cancel *cancel = equeue_alloc(&q, sizeof(struct cancel));
be_bryan 0:b74591d5ab33 316 test_assert(cancel);
be_bryan 0:b74591d5ab33 317 cancel->q = &q;
be_bryan 0:b74591d5ab33 318 cancel->id = 0;
be_bryan 0:b74591d5ab33 319
be_bryan 0:b74591d5ab33 320 id = equeue_post(&q, cancel_func, cancel);
be_bryan 0:b74591d5ab33 321 test_assert(id);
be_bryan 0:b74591d5ab33 322
be_bryan 0:b74591d5ab33 323 cancel->id = equeue_call(&q, simple_func, &touched);
be_bryan 0:b74591d5ab33 324
be_bryan 0:b74591d5ab33 325 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 326 test_assert(!touched);
be_bryan 0:b74591d5ab33 327
be_bryan 0:b74591d5ab33 328 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 329 }
be_bryan 0:b74591d5ab33 330
be_bryan 0:b74591d5ab33 331 void cancel_unnecessarily_test(void) {
be_bryan 0:b74591d5ab33 332 equeue_t q;
be_bryan 0:b74591d5ab33 333 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 334 test_assert(!err);
be_bryan 0:b74591d5ab33 335
be_bryan 0:b74591d5ab33 336 int id = equeue_call(&q, pass_func, 0);
be_bryan 0:b74591d5ab33 337 for (int i = 0; i < 5; i++) {
be_bryan 0:b74591d5ab33 338 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 339 }
be_bryan 0:b74591d5ab33 340
be_bryan 0:b74591d5ab33 341 id = equeue_call(&q, pass_func, 0);
be_bryan 0:b74591d5ab33 342 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 343 for (int i = 0; i < 5; i++) {
be_bryan 0:b74591d5ab33 344 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 345 }
be_bryan 0:b74591d5ab33 346
be_bryan 0:b74591d5ab33 347 bool touched = false;
be_bryan 0:b74591d5ab33 348 equeue_call(&q, simple_func, &touched);
be_bryan 0:b74591d5ab33 349 for (int i = 0; i < 5; i++) {
be_bryan 0:b74591d5ab33 350 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 351 }
be_bryan 0:b74591d5ab33 352
be_bryan 0:b74591d5ab33 353 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 354 test_assert(touched);
be_bryan 0:b74591d5ab33 355
be_bryan 0:b74591d5ab33 356 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 357 }
be_bryan 0:b74591d5ab33 358
be_bryan 0:b74591d5ab33 359 void loop_protect_test(void) {
be_bryan 0:b74591d5ab33 360 equeue_t q;
be_bryan 0:b74591d5ab33 361 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 362 test_assert(!err);
be_bryan 0:b74591d5ab33 363
be_bryan 0:b74591d5ab33 364 bool touched = false;
be_bryan 0:b74591d5ab33 365 equeue_call_every(&q, 0, simple_func, &touched);
be_bryan 0:b74591d5ab33 366
be_bryan 0:b74591d5ab33 367 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 368 test_assert(touched);
be_bryan 0:b74591d5ab33 369
be_bryan 0:b74591d5ab33 370 touched = false;
be_bryan 0:b74591d5ab33 371 equeue_call_every(&q, 1, simple_func, &touched);
be_bryan 0:b74591d5ab33 372
be_bryan 0:b74591d5ab33 373 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 374 test_assert(touched);
be_bryan 0:b74591d5ab33 375
be_bryan 0:b74591d5ab33 376 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 377 }
be_bryan 0:b74591d5ab33 378
be_bryan 0:b74591d5ab33 379 void break_test(void) {
be_bryan 0:b74591d5ab33 380 equeue_t q;
be_bryan 0:b74591d5ab33 381 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 382 test_assert(!err);
be_bryan 0:b74591d5ab33 383
be_bryan 0:b74591d5ab33 384 bool touched = false;
be_bryan 0:b74591d5ab33 385 equeue_call_every(&q, 0, simple_func, &touched);
be_bryan 0:b74591d5ab33 386
be_bryan 0:b74591d5ab33 387 equeue_break(&q);
be_bryan 0:b74591d5ab33 388 equeue_dispatch(&q, -1);
be_bryan 0:b74591d5ab33 389 test_assert(touched);
be_bryan 0:b74591d5ab33 390
be_bryan 0:b74591d5ab33 391 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 392 }
be_bryan 0:b74591d5ab33 393
be_bryan 0:b74591d5ab33 394 void period_test(void) {
be_bryan 0:b74591d5ab33 395 equeue_t q;
be_bryan 0:b74591d5ab33 396 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 397 test_assert(!err);
be_bryan 0:b74591d5ab33 398
be_bryan 0:b74591d5ab33 399 int count = 0;
be_bryan 0:b74591d5ab33 400 equeue_call_every(&q, 10, simple_func, &count);
be_bryan 0:b74591d5ab33 401
be_bryan 0:b74591d5ab33 402 equeue_dispatch(&q, 55);
be_bryan 0:b74591d5ab33 403 test_assert(count == 5);
be_bryan 0:b74591d5ab33 404
be_bryan 0:b74591d5ab33 405 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 406 }
be_bryan 0:b74591d5ab33 407
be_bryan 0:b74591d5ab33 408 void nested_test(void) {
be_bryan 0:b74591d5ab33 409 equeue_t q;
be_bryan 0:b74591d5ab33 410 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 411 test_assert(!err);
be_bryan 0:b74591d5ab33 412
be_bryan 0:b74591d5ab33 413 int touched = 0;
be_bryan 0:b74591d5ab33 414 struct nest *nest = equeue_alloc(&q, sizeof(struct nest));
be_bryan 0:b74591d5ab33 415 test_assert(nest);
be_bryan 0:b74591d5ab33 416 nest->q = &q;
be_bryan 0:b74591d5ab33 417 nest->cb = simple_func;
be_bryan 0:b74591d5ab33 418 nest->data = &touched;
be_bryan 0:b74591d5ab33 419
be_bryan 0:b74591d5ab33 420 int id = equeue_post(&q, nest_func, nest);
be_bryan 0:b74591d5ab33 421 test_assert(id);
be_bryan 0:b74591d5ab33 422
be_bryan 0:b74591d5ab33 423 equeue_dispatch(&q, 5);
be_bryan 0:b74591d5ab33 424 test_assert(touched == 0);
be_bryan 0:b74591d5ab33 425
be_bryan 0:b74591d5ab33 426 equeue_dispatch(&q, 5);
be_bryan 0:b74591d5ab33 427 test_assert(touched == 1);
be_bryan 0:b74591d5ab33 428
be_bryan 0:b74591d5ab33 429 touched = 0;
be_bryan 0:b74591d5ab33 430 nest = equeue_alloc(&q, sizeof(struct nest));
be_bryan 0:b74591d5ab33 431 test_assert(nest);
be_bryan 0:b74591d5ab33 432 nest->q = &q;
be_bryan 0:b74591d5ab33 433 nest->cb = simple_func;
be_bryan 0:b74591d5ab33 434 nest->data = &touched;
be_bryan 0:b74591d5ab33 435
be_bryan 0:b74591d5ab33 436 id = equeue_post(&q, nest_func, nest);
be_bryan 0:b74591d5ab33 437 test_assert(id);
be_bryan 0:b74591d5ab33 438
be_bryan 0:b74591d5ab33 439 equeue_dispatch(&q, 20);
be_bryan 0:b74591d5ab33 440 test_assert(touched == 1);
be_bryan 0:b74591d5ab33 441
be_bryan 0:b74591d5ab33 442 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 443 }
be_bryan 0:b74591d5ab33 444
be_bryan 0:b74591d5ab33 445 void sloth_test(void) {
be_bryan 0:b74591d5ab33 446 equeue_t q;
be_bryan 0:b74591d5ab33 447 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 448 test_assert(!err);
be_bryan 0:b74591d5ab33 449
be_bryan 0:b74591d5ab33 450 int touched = 0;
be_bryan 0:b74591d5ab33 451 int id = equeue_call(&q, sloth_func, &touched);
be_bryan 0:b74591d5ab33 452 test_assert(id);
be_bryan 0:b74591d5ab33 453
be_bryan 0:b74591d5ab33 454 id = equeue_call_in(&q, 5, simple_func, &touched);
be_bryan 0:b74591d5ab33 455 test_assert(id);
be_bryan 0:b74591d5ab33 456
be_bryan 0:b74591d5ab33 457 id = equeue_call_in(&q, 15, simple_func, &touched);
be_bryan 0:b74591d5ab33 458 test_assert(id);
be_bryan 0:b74591d5ab33 459
be_bryan 0:b74591d5ab33 460 equeue_dispatch(&q, 20);
be_bryan 0:b74591d5ab33 461 test_assert(touched == 3);
be_bryan 0:b74591d5ab33 462
be_bryan 0:b74591d5ab33 463 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 464 }
be_bryan 0:b74591d5ab33 465
be_bryan 0:b74591d5ab33 466 void *multithread_thread(void *p) {
be_bryan 0:b74591d5ab33 467 equeue_t *q = (equeue_t *)p;
be_bryan 0:b74591d5ab33 468 equeue_dispatch(q, -1);
be_bryan 0:b74591d5ab33 469 return 0;
be_bryan 0:b74591d5ab33 470 }
be_bryan 0:b74591d5ab33 471
be_bryan 0:b74591d5ab33 472 void multithread_test(void) {
be_bryan 0:b74591d5ab33 473 equeue_t q;
be_bryan 0:b74591d5ab33 474 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 475 test_assert(!err);
be_bryan 0:b74591d5ab33 476
be_bryan 0:b74591d5ab33 477 int touched = 0;
be_bryan 0:b74591d5ab33 478 equeue_call_every(&q, 1, simple_func, &touched);
be_bryan 0:b74591d5ab33 479
be_bryan 0:b74591d5ab33 480 pthread_t thread;
be_bryan 0:b74591d5ab33 481 err = pthread_create(&thread, 0, multithread_thread, &q);
be_bryan 0:b74591d5ab33 482 test_assert(!err);
be_bryan 0:b74591d5ab33 483
be_bryan 0:b74591d5ab33 484 usleep(10000);
be_bryan 0:b74591d5ab33 485 equeue_break(&q);
be_bryan 0:b74591d5ab33 486 err = pthread_join(thread, 0);
be_bryan 0:b74591d5ab33 487 test_assert(!err);
be_bryan 0:b74591d5ab33 488
be_bryan 0:b74591d5ab33 489 test_assert(touched);
be_bryan 0:b74591d5ab33 490
be_bryan 0:b74591d5ab33 491 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 492 }
be_bryan 0:b74591d5ab33 493
be_bryan 0:b74591d5ab33 494 void background_func(void *p, int ms) {
be_bryan 0:b74591d5ab33 495 *(unsigned *)p = ms;
be_bryan 0:b74591d5ab33 496 }
be_bryan 0:b74591d5ab33 497
be_bryan 0:b74591d5ab33 498 void background_test(void) {
be_bryan 0:b74591d5ab33 499 equeue_t q;
be_bryan 0:b74591d5ab33 500 int err = equeue_create(&q, 2048);
be_bryan 0:b74591d5ab33 501 test_assert(!err);
be_bryan 0:b74591d5ab33 502
be_bryan 0:b74591d5ab33 503 int id = equeue_call_in(&q, 20, pass_func, 0);
be_bryan 0:b74591d5ab33 504 test_assert(id);
be_bryan 0:b74591d5ab33 505
be_bryan 0:b74591d5ab33 506 unsigned ms;
be_bryan 0:b74591d5ab33 507 equeue_background(&q, background_func, &ms);
be_bryan 0:b74591d5ab33 508 test_assert(ms == 20);
be_bryan 0:b74591d5ab33 509
be_bryan 0:b74591d5ab33 510 id = equeue_call_in(&q, 10, pass_func, 0);
be_bryan 0:b74591d5ab33 511 test_assert(id);
be_bryan 0:b74591d5ab33 512 test_assert(ms == 10);
be_bryan 0:b74591d5ab33 513
be_bryan 0:b74591d5ab33 514 id = equeue_call(&q, pass_func, 0);
be_bryan 0:b74591d5ab33 515 test_assert(id);
be_bryan 0:b74591d5ab33 516 test_assert(ms == 0);
be_bryan 0:b74591d5ab33 517
be_bryan 0:b74591d5ab33 518 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 519 test_assert(ms == 10);
be_bryan 0:b74591d5ab33 520
be_bryan 0:b74591d5ab33 521 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 522 test_assert(ms == -1);
be_bryan 0:b74591d5ab33 523 }
be_bryan 0:b74591d5ab33 524
be_bryan 0:b74591d5ab33 525 void chain_test(void) {
be_bryan 0:b74591d5ab33 526 equeue_t q1;
be_bryan 0:b74591d5ab33 527 int err = equeue_create(&q1, 2048);
be_bryan 0:b74591d5ab33 528 test_assert(!err);
be_bryan 0:b74591d5ab33 529
be_bryan 0:b74591d5ab33 530 equeue_t q2;
be_bryan 0:b74591d5ab33 531 err = equeue_create(&q2, 2048);
be_bryan 0:b74591d5ab33 532 test_assert(!err);
be_bryan 0:b74591d5ab33 533
be_bryan 0:b74591d5ab33 534 equeue_chain(&q2, &q1);
be_bryan 0:b74591d5ab33 535
be_bryan 0:b74591d5ab33 536 int touched = 0;
be_bryan 0:b74591d5ab33 537
be_bryan 0:b74591d5ab33 538 int id1 = equeue_call_in(&q1, 20, simple_func, &touched);
be_bryan 0:b74591d5ab33 539 int id2 = equeue_call_in(&q2, 20, simple_func, &touched);
be_bryan 0:b74591d5ab33 540 test_assert(id1 && id2);
be_bryan 0:b74591d5ab33 541
be_bryan 0:b74591d5ab33 542 id1 = equeue_call(&q1, simple_func, &touched);
be_bryan 0:b74591d5ab33 543 id2 = equeue_call(&q2, simple_func, &touched);
be_bryan 0:b74591d5ab33 544 test_assert(id1 && id2);
be_bryan 0:b74591d5ab33 545
be_bryan 0:b74591d5ab33 546 id1 = equeue_call_in(&q1, 5, simple_func, &touched);
be_bryan 0:b74591d5ab33 547 id2 = equeue_call_in(&q2, 5, simple_func, &touched);
be_bryan 0:b74591d5ab33 548 test_assert(id1 && id2);
be_bryan 0:b74591d5ab33 549
be_bryan 0:b74591d5ab33 550 equeue_cancel(&q1, id1);
be_bryan 0:b74591d5ab33 551 equeue_cancel(&q2, id2);
be_bryan 0:b74591d5ab33 552
be_bryan 0:b74591d5ab33 553 id1 = equeue_call_in(&q1, 10, simple_func, &touched);
be_bryan 0:b74591d5ab33 554 id2 = equeue_call_in(&q2, 10, simple_func, &touched);
be_bryan 0:b74591d5ab33 555 test_assert(id1 && id2);
be_bryan 0:b74591d5ab33 556
be_bryan 0:b74591d5ab33 557 equeue_dispatch(&q1, 30);
be_bryan 0:b74591d5ab33 558
be_bryan 0:b74591d5ab33 559 test_assert(touched == 6);
be_bryan 0:b74591d5ab33 560
be_bryan 0:b74591d5ab33 561 equeue_destroy(&q1);
be_bryan 0:b74591d5ab33 562 equeue_destroy(&q2);
be_bryan 0:b74591d5ab33 563 }
be_bryan 0:b74591d5ab33 564
be_bryan 0:b74591d5ab33 565 void unchain_test(void) {
be_bryan 0:b74591d5ab33 566 equeue_t q1;
be_bryan 0:b74591d5ab33 567 int err = equeue_create(&q1, 2048);
be_bryan 0:b74591d5ab33 568 test_assert(!err);
be_bryan 0:b74591d5ab33 569
be_bryan 0:b74591d5ab33 570 equeue_t q2;
be_bryan 0:b74591d5ab33 571 err = equeue_create(&q2, 2048);
be_bryan 0:b74591d5ab33 572 test_assert(!err);
be_bryan 0:b74591d5ab33 573
be_bryan 0:b74591d5ab33 574 equeue_chain(&q2, &q1);
be_bryan 0:b74591d5ab33 575
be_bryan 0:b74591d5ab33 576 int touched = 0;
be_bryan 0:b74591d5ab33 577 int id1 = equeue_call(&q1, simple_func, &touched);
be_bryan 0:b74591d5ab33 578 int id2 = equeue_call(&q2, simple_func, &touched);
be_bryan 0:b74591d5ab33 579 test_assert(id1 && id2);
be_bryan 0:b74591d5ab33 580
be_bryan 0:b74591d5ab33 581 equeue_dispatch(&q1, 0);
be_bryan 0:b74591d5ab33 582 test_assert(touched == 2);
be_bryan 0:b74591d5ab33 583
be_bryan 0:b74591d5ab33 584 equeue_chain(&q2, 0);
be_bryan 0:b74591d5ab33 585 equeue_chain(&q1, &q2);
be_bryan 0:b74591d5ab33 586
be_bryan 0:b74591d5ab33 587 id1 = equeue_call(&q1, simple_func, &touched);
be_bryan 0:b74591d5ab33 588 id2 = equeue_call(&q2, simple_func, &touched);
be_bryan 0:b74591d5ab33 589 test_assert(id1 && id2);
be_bryan 0:b74591d5ab33 590
be_bryan 0:b74591d5ab33 591 equeue_dispatch(&q2, 0);
be_bryan 0:b74591d5ab33 592 test_assert(touched == 4);
be_bryan 0:b74591d5ab33 593
be_bryan 0:b74591d5ab33 594 equeue_destroy(&q1);
be_bryan 0:b74591d5ab33 595 equeue_destroy(&q2);
be_bryan 0:b74591d5ab33 596 }
be_bryan 0:b74591d5ab33 597
be_bryan 0:b74591d5ab33 598 // Barrage tests
be_bryan 0:b74591d5ab33 599 void simple_barrage_test(int N) {
be_bryan 0:b74591d5ab33 600 equeue_t q;
be_bryan 0:b74591d5ab33 601 int err = equeue_create(&q, N*(EQUEUE_EVENT_SIZE+sizeof(struct timing)));
be_bryan 0:b74591d5ab33 602 test_assert(!err);
be_bryan 0:b74591d5ab33 603
be_bryan 0:b74591d5ab33 604 for (int i = 0; i < N; i++) {
be_bryan 0:b74591d5ab33 605 struct timing *timing = equeue_alloc(&q, sizeof(struct timing));
be_bryan 0:b74591d5ab33 606 test_assert(timing);
be_bryan 0:b74591d5ab33 607
be_bryan 0:b74591d5ab33 608 timing->tick = equeue_tick();
be_bryan 0:b74591d5ab33 609 timing->delay = (i+1)*100;
be_bryan 0:b74591d5ab33 610 equeue_event_delay(timing, timing->delay);
be_bryan 0:b74591d5ab33 611 equeue_event_period(timing, timing->delay);
be_bryan 0:b74591d5ab33 612
be_bryan 0:b74591d5ab33 613 int id = equeue_post(&q, timing_func, timing);
be_bryan 0:b74591d5ab33 614 test_assert(id);
be_bryan 0:b74591d5ab33 615 }
be_bryan 0:b74591d5ab33 616
be_bryan 0:b74591d5ab33 617 equeue_dispatch(&q, N*100);
be_bryan 0:b74591d5ab33 618
be_bryan 0:b74591d5ab33 619 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 620 }
be_bryan 0:b74591d5ab33 621
be_bryan 0:b74591d5ab33 622 void fragmenting_barrage_test(int N) {
be_bryan 0:b74591d5ab33 623 equeue_t q;
be_bryan 0:b74591d5ab33 624 int err = equeue_create(&q,
be_bryan 0:b74591d5ab33 625 2*N*(EQUEUE_EVENT_SIZE+sizeof(struct fragment)+N*sizeof(int)));
be_bryan 0:b74591d5ab33 626 test_assert(!err);
be_bryan 0:b74591d5ab33 627
be_bryan 0:b74591d5ab33 628 for (int i = 0; i < N; i++) {
be_bryan 0:b74591d5ab33 629 size_t size = sizeof(struct fragment) + i*sizeof(int);
be_bryan 0:b74591d5ab33 630 struct fragment *fragment = equeue_alloc(&q, size);
be_bryan 0:b74591d5ab33 631 test_assert(fragment);
be_bryan 0:b74591d5ab33 632
be_bryan 0:b74591d5ab33 633 fragment->q = &q;
be_bryan 0:b74591d5ab33 634 fragment->size = size;
be_bryan 0:b74591d5ab33 635 fragment->timing.tick = equeue_tick();
be_bryan 0:b74591d5ab33 636 fragment->timing.delay = (i+1)*100;
be_bryan 0:b74591d5ab33 637 equeue_event_delay(fragment, fragment->timing.delay);
be_bryan 0:b74591d5ab33 638
be_bryan 0:b74591d5ab33 639 int id = equeue_post(&q, fragment_func, fragment);
be_bryan 0:b74591d5ab33 640 test_assert(id);
be_bryan 0:b74591d5ab33 641 }
be_bryan 0:b74591d5ab33 642
be_bryan 0:b74591d5ab33 643 equeue_dispatch(&q, N*100);
be_bryan 0:b74591d5ab33 644
be_bryan 0:b74591d5ab33 645 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 646 }
be_bryan 0:b74591d5ab33 647
be_bryan 0:b74591d5ab33 648 struct ethread {
be_bryan 0:b74591d5ab33 649 pthread_t thread;
be_bryan 0:b74591d5ab33 650 equeue_t *q;
be_bryan 0:b74591d5ab33 651 int ms;
be_bryan 0:b74591d5ab33 652 };
be_bryan 0:b74591d5ab33 653
be_bryan 0:b74591d5ab33 654 static void *ethread_dispatch(void *p) {
be_bryan 0:b74591d5ab33 655 struct ethread *t = (struct ethread*)p;
be_bryan 0:b74591d5ab33 656 equeue_dispatch(t->q, t->ms);
be_bryan 0:b74591d5ab33 657 return 0;
be_bryan 0:b74591d5ab33 658 }
be_bryan 0:b74591d5ab33 659
be_bryan 0:b74591d5ab33 660 void multithreaded_barrage_test(int N) {
be_bryan 0:b74591d5ab33 661 equeue_t q;
be_bryan 0:b74591d5ab33 662 int err = equeue_create(&q, N*(EQUEUE_EVENT_SIZE+sizeof(struct timing)));
be_bryan 0:b74591d5ab33 663 test_assert(!err);
be_bryan 0:b74591d5ab33 664
be_bryan 0:b74591d5ab33 665 struct ethread t;
be_bryan 0:b74591d5ab33 666 t.q = &q;
be_bryan 0:b74591d5ab33 667 t.ms = N*100;
be_bryan 0:b74591d5ab33 668 err = pthread_create(&t.thread, 0, ethread_dispatch, &t);
be_bryan 0:b74591d5ab33 669 test_assert(!err);
be_bryan 0:b74591d5ab33 670
be_bryan 0:b74591d5ab33 671 for (int i = 0; i < N; i++) {
be_bryan 0:b74591d5ab33 672 struct timing *timing = equeue_alloc(&q, sizeof(struct timing));
be_bryan 0:b74591d5ab33 673 test_assert(timing);
be_bryan 0:b74591d5ab33 674
be_bryan 0:b74591d5ab33 675 timing->tick = equeue_tick();
be_bryan 0:b74591d5ab33 676 timing->delay = (i+1)*100;
be_bryan 0:b74591d5ab33 677 equeue_event_delay(timing, timing->delay);
be_bryan 0:b74591d5ab33 678 equeue_event_period(timing, timing->delay);
be_bryan 0:b74591d5ab33 679
be_bryan 0:b74591d5ab33 680 int id = equeue_post(&q, timing_func, timing);
be_bryan 0:b74591d5ab33 681 test_assert(id);
be_bryan 0:b74591d5ab33 682 }
be_bryan 0:b74591d5ab33 683
be_bryan 0:b74591d5ab33 684 err = pthread_join(t.thread, 0);
be_bryan 0:b74591d5ab33 685 test_assert(!err);
be_bryan 0:b74591d5ab33 686
be_bryan 0:b74591d5ab33 687 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 688 }
be_bryan 0:b74591d5ab33 689
be_bryan 0:b74591d5ab33 690
be_bryan 0:b74591d5ab33 691 int main() {
be_bryan 0:b74591d5ab33 692 printf("beginning tests...\n");
be_bryan 0:b74591d5ab33 693
be_bryan 0:b74591d5ab33 694 test_run(simple_call_test);
be_bryan 0:b74591d5ab33 695 test_run(simple_call_in_test);
be_bryan 0:b74591d5ab33 696 test_run(simple_call_every_test);
be_bryan 0:b74591d5ab33 697 test_run(simple_post_test);
be_bryan 0:b74591d5ab33 698 test_run(destructor_test);
be_bryan 0:b74591d5ab33 699 test_run(allocation_failure_test);
be_bryan 0:b74591d5ab33 700 test_run(cancel_test, 20);
be_bryan 0:b74591d5ab33 701 test_run(cancel_inflight_test);
be_bryan 0:b74591d5ab33 702 test_run(cancel_unnecessarily_test);
be_bryan 0:b74591d5ab33 703 test_run(loop_protect_test);
be_bryan 0:b74591d5ab33 704 test_run(break_test);
be_bryan 0:b74591d5ab33 705 test_run(period_test);
be_bryan 0:b74591d5ab33 706 test_run(nested_test);
be_bryan 0:b74591d5ab33 707 test_run(sloth_test);
be_bryan 0:b74591d5ab33 708 test_run(background_test);
be_bryan 0:b74591d5ab33 709 test_run(chain_test);
be_bryan 0:b74591d5ab33 710 test_run(unchain_test);
be_bryan 0:b74591d5ab33 711 test_run(multithread_test);
be_bryan 0:b74591d5ab33 712 test_run(simple_barrage_test, 20);
be_bryan 0:b74591d5ab33 713 test_run(fragmenting_barrage_test, 20);
be_bryan 0:b74591d5ab33 714 test_run(multithreaded_barrage_test, 20);
be_bryan 0:b74591d5ab33 715
be_bryan 0:b74591d5ab33 716 printf("done!\n");
be_bryan 0:b74591d5ab33 717 return test_failure;
be_bryan 0:b74591d5ab33 718 }