event: t_timer_fcns.c Source File

00001 /*
00002 ** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
00003 **
00004 ** This program is free software; you can redistribute it and/or modify
00005 ** it under the terms of the GNU General Public License as published by
00006 ** the Free Software Foundation; either version 2 of the License, or
00007 ** (at your option) any later version.
00008 **
00009 ** This program is distributed in the hope that it will be useful,
00010 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
00011 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012 ** GNU General Public License for more details.
00013 **
00014 ** You should have received a copy of the GNU General Public License
00015 ** along with this program; if not, write to the Free Software
00016 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017 **
00018 ** @(#)$Id: t_timer_fcns.c,v 1.3 2005/12/18 00:15:17 klmitch Exp $
00019 */
00028 #include "event-test.h"
00029 
00030 #include <sys/time.h>
00031 
00032 RCSTAG("@(#)$Id: t_timer_fcns.c,v 1.3 2005/12/18 00:15:17 klmitch Exp $");
00033 
00034 TEST_PROG(t_timer_fcns, "Test operation of timer manipulation functions")
00035      TEST_ARG(t_timer_fcns, "<event-test.tc>")
00036      TEST_ARG(t_timer_fcns, "<engmodule.la>")
00037      TEST_DEP(t_timer_fcns, t_evg_alloc)
00038 
00047 #define TTF_SEC         1126573395
00048 
00056 #define TTF_USEC        1234
00057 
00072 int
00073 gettimeofday(struct timeval *tv, struct timezone *tz)
00074 {
00075   tv->tv_sec = TTF_SEC; /* Set the "current" time (for testing purposes) */
00076   tv->tv_usec = TTF_USEC;
00077 
00078   return 0;
00079 }
00080 
00087 struct test_timer {
00088   const ev_timtype_t type;      
00089   const time_t sec;             
00090   const suseconds_t usec;       
00091   const time_t e_sec;           
00092   const suseconds_t e_usec;     
00093   const ev_flags_t flags;       
00094   ev_tim_t *timer;              
00095 };
00096 
00103 #define TT_FLAG_DESTROY 0x0001
00104 
00122 #define timer_init(type, sec, usec, flags)                                    \
00123   { (type), (sec), (usec), ((type) == TT_ABSOLUTE ? (sec) : (sec) + TTF_SEC), \
00124     ((type) == TT_ABSOLUTE ? (usec) : (usec) + TTF_USEC), (flags), 0 }
00125 
00132 static struct test_timer timers[] = {
00133   timer_init(TT_PERIODIC, 47, 1361, TT_FLAG_DESTROY),
00134   timer_init(TT_PERIODIC, 8, 3302, 0),
00135   timer_init(TT_RELATIVE, 44, 3411, TT_FLAG_DESTROY),
00136   timer_init(TT_RELATIVE, 12, 1836, 0),
00137   timer_init(TT_ABSOLUTE, TTF_SEC + 15, TTF_USEC + 4422, TT_FLAG_DESTROY),
00138   timer_init(TT_PERIODIC, 42, 2714, 0),
00139   timer_init(TT_ABSOLUTE, TTF_SEC + 49, TTF_USEC + 1979, TT_FLAG_DESTROY),
00140   timer_init(TT_PERIODIC, 17, 1635, TT_FLAG_DESTROY),
00141   timer_init(TT_ABSOLUTE, TTF_SEC + 20, TTF_USEC + 4995, 0),
00142   timer_init(TT_ABSOLUTE, TTF_SEC + 7, TTF_USEC + 1599, TT_FLAG_DESTROY),
00143   timer_init(TT_RELATIVE, 37, 2669, TT_FLAG_DESTROY),
00144   timer_init(TT_PERIODIC, 47, 4197, TT_FLAG_DESTROY),
00145   timer_init(TT_RELATIVE, 47, 3253, 0),
00146   timer_init(TT_RELATIVE, 1, 2703, TT_FLAG_DESTROY),
00147   timer_init(TT_PERIODIC, 22, 1511, 0),
00148   timer_init(TT_ABSOLUTE, TTF_SEC + 11, TTF_USEC + 4312, TT_FLAG_DESTROY),
00149   timer_init(TT_ABSOLUTE, TTF_SEC + 33, TTF_USEC + 2035, TT_FLAG_DESTROY),
00150   timer_init(TT_PERIODIC, 41, 3077, TT_FLAG_DESTROY),
00151   timer_init(TT_ABSOLUTE, TTF_SEC + 17, TTF_USEC + 2143, 0),
00152   timer_init(TT_ABSOLUTE, TTF_SEC + 5, TTF_USEC + 232, TT_FLAG_DESTROY),
00153   timer_init(TT_RELATIVE, 35, 2884, TT_FLAG_DESTROY),
00154   timer_init(TT_PERIODIC, 27, 4372, TT_FLAG_DESTROY),
00155   timer_init(TT_PERIODIC, 39, 4811, TT_FLAG_DESTROY),
00156   timer_init(TT_ABSOLUTE, TTF_SEC + 5, TTF_USEC + 633, 0),
00157   timer_init(TT_RELATIVE, 41, 1559, 0),
00158   timer_init(TT_ABSOLUTE, TTF_SEC + 12, TTF_USEC + 393, 0),
00159   timer_init(TT_ABSOLUTE, TTF_SEC + 40, TTF_USEC + 3946, 0),
00160   timer_init(TT_ABSOLUTE, TTF_SEC + 48, TTF_USEC + 1220, 0),
00161   timer_init(TT_ABSOLUTE, TTF_SEC + 34, TTF_USEC + 275, 0),
00162   timer_init(TT_ABSOLUTE, TTF_SEC + 14, TTF_USEC + 752, 0),
00163   timer_init(TT_RELATIVE, 25, 4716, TT_FLAG_DESTROY),
00164   timer_init(TT_ABSOLUTE, TTF_SEC + 15, TTF_USEC + 2953, 0),
00165   timer_init(TT_ABSOLUTE, TTF_SEC + 30, TTF_USEC + 231, 0),
00166   timer_init(TT_ABSOLUTE, TTF_SEC + 25, TTF_USEC + 721, TT_FLAG_DESTROY),
00167   timer_init(TT_ABSOLUTE, TTF_SEC + 28, TTF_USEC + 217, TT_FLAG_DESTROY),
00168   timer_init(TT_RELATIVE, 4, 121, TT_FLAG_DESTROY),
00169   timer_init(TT_RELATIVE, 23, 4198, 0),
00170   timer_init(TT_PERIODIC, 21, 3641, 0),
00171   timer_init(TT_ABSOLUTE, TTF_SEC + 48, TTF_USEC + 2214, 0),
00172   timer_init(TT_RELATIVE, 19, 2721, TT_FLAG_DESTROY)
00173 };
00174 
00181 struct test_resched {
00182   const int timer;              
00183   const ev_timtype_t type;      
00184   const time_t sec;             
00185   const suseconds_t usec;       
00186   const time_t e_sec;           
00187   const suseconds_t e_usec;     
00188 };
00189 
00207 #define resched_init(timer, type, sec, usec)                                  \
00208   { (timer), (type), (sec), (usec),                                           \
00209     ((type) == TT_ABSOLUTE ? (sec) : (sec) + TTF_SEC),                        \
00210     ((type) == TT_ABSOLUTE ? (usec) : (usec) + TTF_USEC) }
00211 
00218 static struct test_resched resched[] = {
00219   resched_init(31, TT_PERIODIC, 11, 646),
00220   resched_init(11, TT_RELATIVE, 40, 2183),
00221   resched_init(2, TT_PERIODIC, 49, 2132),
00222   resched_init(31, TT_RELATIVE, 9, 4264),
00223   resched_init(23, TT_RELATIVE, 3, 2171),
00224   resched_init(2, TT_RELATIVE, 0, 589),
00225   resched_init(31, TT_ABSOLUTE, TTF_SEC + 24, TTF_USEC + 3978),
00226   resched_init(34, TT_ABSOLUTE, TTF_SEC + 4, TTF_USEC + 4553),
00227   resched_init(20, TT_PERIODIC, 36, 3370),
00228   resched_init(38, TT_PERIODIC, 10, 1455),
00229   resched_init(35, TT_RELATIVE, 35, 2806),
00230   resched_init(3, TT_RELATIVE, 23, 4813),
00231   resched_init(10, TT_PERIODIC, 18, 1256),
00232   resched_init(9, TT_PERIODIC, 30, 1329),
00233   resched_init(19, TT_RELATIVE, 39, 4636),
00234   resched_init(14, TT_PERIODIC, 48, 4756),
00235   resched_init(8, TT_ABSOLUTE, TTF_SEC + 10, TTF_USEC + 83),
00236   resched_init(21, TT_RELATIVE, 14, 3142),
00237   resched_init(14, TT_PERIODIC, 39, 3560),
00238   resched_init(25, TT_RELATIVE, 38, 3384),
00239   resched_init(17, TT_PERIODIC, 27, 4173),
00240   resched_init(32, TT_RELATIVE, 44, 1567),
00241   resched_init(37, TT_ABSOLUTE, TTF_SEC + 13, TTF_USEC + 88),
00242   resched_init(31, TT_PERIODIC, 35, 2316),
00243   resched_init(23, TT_RELATIVE, 24, 140),
00244   resched_init(37, TT_PERIODIC, 1, 268),
00245   resched_init(4, TT_RELATIVE, 24, 2044),
00246   resched_init(12, TT_RELATIVE, 19, 1806),
00247   resched_init(37, TT_PERIODIC, 10, 2635),
00248   resched_init(34, TT_PERIODIC, 31, 430),
00249   resched_init(33, TT_PERIODIC, 26, 2719),
00250   resched_init(32, TT_PERIODIC, 27, 4442),
00251   resched_init(39, TT_ABSOLUTE, TTF_SEC + 12, TTF_USEC + 3899),
00252   resched_init(25, TT_RELATIVE, 37, 1201),
00253   resched_init(17, TT_ABSOLUTE, TTF_SEC + 24, TTF_USEC + 2243),
00254   resched_init(27, TT_ABSOLUTE, TTF_SEC + 21, TTF_USEC + 2809),
00255   resched_init(10, TT_RELATIVE, 35, 3751),
00256   resched_init(30, TT_PERIODIC, 39, 3959),
00257   resched_init(35, TT_ABSOLUTE, TTF_SEC + 14, TTF_USEC + 4380),
00258   resched_init(23, TT_ABSOLUTE, TTF_SEC, TTF_USEC + 3641),
00259   resched_init(12, TT_RELATIVE, 39, 2804),
00260   resched_init(28, TT_RELATIVE, 34, 3533),
00261   resched_init(31, TT_ABSOLUTE, TTF_SEC + 10, TTF_USEC + 2192),
00262   resched_init(26, TT_PERIODIC, 11, 2218),
00263   resched_init(0, TT_ABSOLUTE, TTF_SEC + 45, TTF_USEC + 3015),
00264   resched_init(16, TT_PERIODIC, 3, 786),
00265   resched_init(28, TT_PERIODIC, 46, 2309),
00266   resched_init(17, TT_PERIODIC, 31, 2036),
00267   resched_init(28, TT_RELATIVE, 14, 894),
00268   resched_init(2, TT_RELATIVE, 3, 2191),
00269   resched_init(32, TT_PERIODIC, 26, 3723),
00270   resched_init(0, TT_RELATIVE, 1, 1022),
00271   resched_init(22, TT_PERIODIC, 40, 4956),
00272   resched_init(35, TT_RELATIVE, 15, 3307),
00273   resched_init(18, TT_RELATIVE, 2, 3348),
00274   resched_init(29, TT_RELATIVE, 9, 1801),
00275   resched_init(22, TT_PERIODIC, 24, 240),
00276   resched_init(7, TT_RELATIVE, 22, 4288),
00277   resched_init(37, TT_ABSOLUTE, TTF_SEC + 21, TTF_USEC + 1777),
00278   resched_init(39, TT_PERIODIC, 23, 4800),
00279   resched_init(36, TT_ABSOLUTE, TTF_SEC + 44, TTF_USEC + 3985),
00280   resched_init(2, TT_ABSOLUTE, TTF_SEC + 9, TTF_USEC + 1834),
00281   resched_init(15, TT_ABSOLUTE, TTF_SEC + 44, TTF_USEC + 3962),
00282   resched_init(4, TT_ABSOLUTE, TTF_SEC + 1, TTF_USEC + 4201),
00283   resched_init(10, TT_PERIODIC, 13, 2800),
00284   resched_init(39, TT_RELATIVE, 27, 3210),
00285   resched_init(30, TT_RELATIVE, 4, 760),
00286   resched_init(35, TT_ABSOLUTE, TTF_SEC + 10, TTF_USEC + 3007),
00287   resched_init(35, TT_ABSOLUTE, TTF_SEC + 20, TTF_USEC + 2895),
00288   resched_init(14, TT_RELATIVE, 47, 4247),
00289   resched_init(12, TT_PERIODIC, 30, 3561),
00290   resched_init(22, TT_RELATIVE, 38, 4755),
00291   resched_init(5, TT_PERIODIC, 15, 1213),
00292   resched_init(12, TT_PERIODIC, 15, 4451),
00293   resched_init(2, TT_RELATIVE, 39, 451),
00294   resched_init(18, TT_ABSOLUTE, TTF_SEC + 21, TTF_USEC + 630),
00295   resched_init(28, TT_PERIODIC, 10, 1554),
00296   resched_init(14, TT_ABSOLUTE, TTF_SEC + 15, TTF_USEC + 3628),
00297   resched_init(0, TT_RELATIVE, 31, 3619),
00298   resched_init(9, TT_ABSOLUTE, TTF_SEC + 46, TTF_USEC + 2008)
00299 };
00300 
00301 /* These functions are too valuable to do away with, but the test
00302  * program doesn't actually need them...
00303  */
00304 
00305 /* static void */
00306 /* print_node(ev_ctx_t *ctx, char *prefix, int plen, int pipe, ev_tim_t *node, */
00307 /*         int depth) */
00308 /* { */
00309 /*   const char *tim_type[] = { "ABSOLUTE", "RELATIVE", "PERIODIC" }; */
00310 
00311 /*   if (!node) { */
00312 /*     printf("%.*s%c-NO NODE\n", plen, prefix, pipe); */
00313 /*     return; */
00314 /*   } */
00315 
00316 /*   printf("%.*s%c-%p %s: (%ld,%ld) (%ld,%ld)%s%s\n", plen, prefix, pipe, */
00317 /*       (void *)node, tim_type[ti_type(node)], ti_value(node)->tv_sec, */
00318 /*       ti_value(node)->tv_usec, ti_expire(node)->tv_sec, */
00319 /*       ti_expire(node)->tv_usec, */
00320 /*       node == ctx->ec_timtree.tt_root ? " (ROOT NODE)" : "", */
00321 /*       node == ctx->ec_timtree.tt_insert ? " (INSERT POINT)" : ""); */
00322 
00323 /*   if (pipe != '|') */
00324 /*     pipe = ' '; */
00325 
00326 /*   printf("%.*s%c | (^ %p > %p < %p l %p r %p d %d)\n", plen, */
00327 /*       prefix, pipe, (void *)node->ti_node.tn_parent, */
00328 /*       (void *)node->ti_node.tn_next, (void *)node->ti_node.tn_prev, */
00329 /*       (void *)node->ti_node.tn_left, (void *)node->ti_node.tn_right, depth); */
00330 
00331 /*   prefix[plen] = pipe; */
00332 /*   prefix[plen + 1] = ' '; */
00333 
00334 /*   print_node(ctx, prefix, plen + 2, '|', node->ti_node.tn_left, depth + 1); */
00335 /*   print_node(ctx, prefix, plen + 2, '`', node->ti_node.tn_right, depth + 1); */
00336 /* } */
00337 
00338 /* static void */
00339 /* print_tree(ev_ctx_t *ctx) */
00340 /* { */
00341 /*   char prefix[30]; */
00342 
00343 /*   printf("Timer tree rooted at %p; insertion cursor %p\n", */
00344 /*       (void *)ctx->ec_timtree.tt_root, (void *)ctx->ec_timtree.tt_insert); */
00345 
00346 /*   prefix[0] = '\0'; */
00347 /*   print_node(ctx, prefix, 0, '`', ctx->ec_timtree.tt_root, 0); */
00348 /* } */
00349 
00356 int
00357 main(int argc, char **argv)
00358 {
00359   int i;
00360   char *prog;
00361   ev_err_t err;
00362   ev_ctx_t ctx;
00363   struct timeval tv;
00364 
00365   ev_test_init(t_timer_fcns); /* initialize test program */
00366   ev_prog_name(prog, argv); /* calculate program name... */
00367   ev_lib_init(argc, argv, prog, &ctx); /* initialize event library */
00368 
00369   TEST_DECL(t_timer_fcns, timer_create, "Test that timers may be created")
00370     for (i = 0; i < sizeof(timers) / sizeof(struct test_timer); i++) {
00371       /* Set up the timer value... */
00372       tv.tv_sec = timers[i].sec;
00373       tv.tv_usec = timers[i].usec;
00374 
00375       /* execute the test case... */
00376       if ((err = timer_create(&ctx, timers[i].type, &tv, 0, 0,
00377                               &timers[i].timer)))
00378         FAIL(TEST_NAME(timer_create), FATAL(0), "timer_create() failed with "
00379              "error %u", err);
00380       else if (ti_type(timers[i].timer) != timers[i].type ||
00381                ti_value(timers[i].timer)->tv_sec != timers[i].sec ||
00382                ti_value(timers[i].timer)->tv_usec != timers[i].usec ||
00383                ti_expire(timers[i].timer)->tv_sec != timers[i].e_sec ||
00384                ti_expire(timers[i].timer)->tv_usec != timers[i].e_usec)
00385         FAIL(TEST_NAME(timer_create), FATAL(0), "timer_create() failed to set "
00386              "timer values properly");
00387     }
00388   PASS(TEST_NAME(timer_create), "timer_create() created timers correctly");
00389 
00390 /*   print_tree(&ctx); */
00391 
00392   TEST_DECL(t_timer_fcns, timer_resched, "Test that timers may be rescheduled")
00393     for (i = 0; i < sizeof(resched) / sizeof(struct test_resched); i++) {
00394       /* Set up the timer value... */
00395       tv.tv_sec = resched[i].sec;
00396       tv.tv_usec = resched[i].usec;
00397 
00398       /* execute the test case... */
00399       if ((err = timer_resched(&ctx, timers[resched[i].timer].timer,
00400                                resched[i].type, &tv)))
00401         FAIL(TEST_NAME(timer_resched), FATAL(0), "timer_resched() failed with "
00402              "error %u", err);
00403       else if (ti_type(timers[resched[i].timer].timer) !=
00404                resched[i].type ||
00405                ti_value(timers[resched[i].timer].timer)->tv_sec !=
00406                resched[i].sec ||
00407                ti_value(timers[resched[i].timer].timer)->tv_usec !=
00408                resched[i].usec ||
00409                ti_expire(timers[resched[i].timer].timer)->tv_sec !=
00410                resched[i].e_sec ||
00411                ti_expire(timers[resched[i].timer].timer)->tv_usec !=
00412                resched[i].e_usec)
00413         FAIL(TEST_NAME(timer_create), FATAL(0), "timer_resched() failed to "
00414              "set timer values properly");
00415     }
00416   PASS(TEST_NAME(timer_resched), "timer_resched() rescheduled timers "
00417        "correctly");
00418 
00419 /*   print_tree(&ctx); */
00420 
00421   TEST_DECL(t_timer_fcns, timer_destroy, "Test that timers may be destroyed")
00422     for (i = 0; i < sizeof(timers) / sizeof(struct test_timer); i++) {
00423       if (!(timers[i].flags & TT_FLAG_DESTROY))
00424         continue; /* skip the ones we're keeping... */
00425 
00426       if ((err = timer_destroy(&ctx, timers[i].timer)))
00427         FAIL(TEST_NAME(timer_destroy), FATAL(0), "timer_destroy() failed with "
00428              "error %u", err);
00429     }
00430   PASS(TEST_NAME(timer_destroy), "timer_destroy() destroyed timers correctly");
00431 
00432 /*   print_tree(&ctx); */
00433 
00434   return 0;
00435 }