tests/lib/test_timer_correctness.c

   1 /*
   2  * Test program to verify that scheduled timers are executed in the
   3  * correct order.
   4  *
   5  * Copyright (C) 2013 by Open Source Routing.
   6  * Copyright (C) 2013 by Internet Systems Consortium, Inc. ("ISC")
   7  *
   8  * This file is part of Quagga
   9  *
  10  * Quagga is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the
  12  * Free Software Foundation; either version 2, or (at your option) any
  13  * later version.
  14  *
  15  * Quagga is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; see the file COPYING; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <zebra.h>
  26
  27 #include <stdio.h>
  28 #include <unistd.h>
  29
  30 #include "memory.h"
  31 #include "pqueue.h"
  32 #include "prng.h"
  33 #include "thread.h"
  34
  35 #define SCHEDULE_TIMERS 800
  36 #define REMOVE_TIMERS   200
  37
  38 #define TIMESTR_LEN strlen("4294967296.999999")
  39
  40 struct thread_master *master;
  41
  42 static size_t log_buf_len;
  43 static size_t log_buf_pos;
  44 static char *log_buf;
  45
  46 static size_t expected_buf_len;
  47 static size_t expected_buf_pos;
  48 static char *expected_buf;
  49
  50 static struct prng *prng;
  51
  52 static struct thread **timers;
  53
  54 static int timers_pending;
  55
  56 static void terminate_test(void)
  57 {
  58         int exit_code;
  59
  60         if (strcmp(log_buf, expected_buf)) {
  61                 fprintf(stderr,
  62                         "Expected output and received output differ.\n");
  63                 fprintf(stderr, "---Expected output: ---\n%s", expected_buf);
  64                 fprintf(stderr, "---Actual output: ---\n%s", log_buf);
  65                 exit_code = 1;
  66         } else {
  67                 printf("Expected output and actual output match.\n");
  68                 exit_code = 0;
  69         }
  70
  71         thread_master_free(master);
  72         XFREE(MTYPE_TMP, log_buf);
  73         XFREE(MTYPE_TMP, expected_buf);
  74         prng_free(prng);
  75         XFREE(MTYPE_TMP, timers);
  76
  77         exit(exit_code);
  78 }
  79
  80 static int timer_func(struct thread *thread)
  81 {
  82         int rv;
  83
  84         rv = snprintf(log_buf + log_buf_pos, log_buf_len - log_buf_pos, "%s\n",
  85                       (char *)thread->arg);
  86         assert(rv >= 0);
  87         log_buf_pos += rv;
  88         assert(log_buf_pos < log_buf_len);
  89         XFREE(MTYPE_TMP, thread->arg);
  90
  91         timers_pending--;
  92         if (!timers_pending)
  93                 terminate_test();
  94
  95         return 0;
  96 }
  97
  98 static int cmp_timeval(const void *a, const void *b)
  99 {
 100         const struct timeval *ta = *(struct timeval * const *)a;
 101         const struct timeval *tb = *(struct timeval * const *)b;
 102
 103         if (timercmp(ta, tb, <))
 104                 return -1;
 105         if (timercmp(ta, tb, >))
 106                 return 1;
 107         return 0;
 108 }
 109
 110 int main(int argc, char **argv)
 111 {
 112         int i, j;
 113         struct thread t;
 114         struct timeval **alarms;
 115
 116         master = thread_master_create(NULL);
 117
 118         log_buf_len = SCHEDULE_TIMERS * (TIMESTR_LEN + 1) + 1;
 119         log_buf_pos = 0;
 120         log_buf = XMALLOC(MTYPE_TMP, log_buf_len);
 121
 122         expected_buf_len = SCHEDULE_TIMERS * (TIMESTR_LEN + 1) + 1;
 123         expected_buf_pos = 0;
 124         expected_buf = XMALLOC(MTYPE_TMP, expected_buf_len);
 125
 126         prng = prng_new(0);
 127
 128         timers = XMALLOC(MTYPE_TMP, SCHEDULE_TIMERS * sizeof(*timers));
 129
 130         for (i = 0; i < SCHEDULE_TIMERS; i++) {
 131                 long interval_msec;
 132                 int ret;
 133                 char *arg;
 134
 135                 /* Schedule timers to expire in 0..5 seconds */
 136                 interval_msec = prng_rand(prng) % 5000;
 137                 arg = XMALLOC(MTYPE_TMP, TIMESTR_LEN + 1);
 138                 timers[i] = NULL;
 139                 thread_add_timer_msec(master, timer_func, arg, interval_msec,
 140                                       &timers[i]);
 141                 ret = snprintf(arg, TIMESTR_LEN + 1, "%lld.%06lld",
 142                                (long long)timers[i]->u.sands.tv_sec,
 143                                (long long)timers[i]->u.sands.tv_usec);
 144                 assert(ret > 0);
 145                 assert((size_t)ret < TIMESTR_LEN + 1);
 146                 timers_pending++;
 147         }
 148
 149         for (i = 0; i < REMOVE_TIMERS; i++) {
 150                 int index;
 151
 152                 index = prng_rand(prng) % SCHEDULE_TIMERS;
 153                 if (!timers[index])
 154                         continue;
 155
 156                 XFREE(MTYPE_TMP, timers[index]->arg);
 157                 thread_cancel(timers[index]);
 158                 timers[index] = NULL;
 159                 timers_pending--;
 160         }
 161
 162         /* We create an array of pointers to the alarm times and sort
 163          * that array. That sorted array is used to generate a string
 164          * representing the expected "output" of the timers when they
 165          * are run. */
 166         j = 0;
 167         alarms = XMALLOC(MTYPE_TMP, timers_pending * sizeof(*alarms));
 168         for (i = 0; i < SCHEDULE_TIMERS; i++) {
 169                 if (!timers[i])
 170                         continue;
 171                 alarms[j++] = &timers[i]->u.sands;
 172         }
 173         qsort(alarms, j, sizeof(*alarms), cmp_timeval);
 174         for (i = 0; i < j; i++) {
 175                 int ret;
 176
 177                 ret = snprintf(expected_buf + expected_buf_pos,
 178                                expected_buf_len - expected_buf_pos,
 179                                "%lld.%06lld\n", (long long)alarms[i]->tv_sec,
 180                                (long long)alarms[i]->tv_usec);
 181                 assert(ret > 0);
 182                 expected_buf_pos += ret;
 183                 assert(expected_buf_pos < expected_buf_len);
 184         }
 185         XFREE(MTYPE_TMP, alarms);
 186
 187         while (thread_fetch(master, &t))
 188                 thread_call(&t);
 189
 190         return 0;
 191 }