eglib/test/test.c

   1 /*
   2  * EGLib Unit Group/Test Runners
   3  *
   4  * Author:
   5  *   Aaron Bockover (abockover@novell.com)
   6  *
   7  * (C) 2006 Novell, Inc.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining
  10  * a copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28
  29 #ifndef _GNU_SOURCE
  30 #define _GNU_SOURCE
  31 #endif
  32
  33 #include <config.h>
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <stdarg.h>
  38 #include <glib.h>
  39 #ifdef HAVE_SYS_TIME_H
  40 #include <sys/time.h>
  41 #endif
  42 #ifdef G_OS_WIN32
  43 #include <winsock2.h>
  44 #endif
  45
  46 #include "test.h"
  47
  48 extern gint global_passed, global_tests;
  49
  50 #ifndef HAVE_VASPRINTF
  51   /* systen does not provide a vasprintf function, use the one
  52      provided within eglib itself */
  53 extern int vasprintf(char **ret, const char *format, va_list ap);
  54 #endif
  55
  56 static gchar *last_result = NULL;
  57
  58 gboolean
  59 run_test(Test *test, gchar **result_out)
  60 {
  61         gchar *result;
  62
  63         if((result = test->handler()) == NULL) {
  64                 *result_out = NULL;
  65                 return TRUE;
  66         } else {
  67                 *result_out = result;
  68                 return FALSE;
  69         }
  70 }
  71
  72 gboolean
  73 run_group(Group *group, gint iterations, gboolean quiet,
  74         gboolean time, gchar *tests_to_run_s)
  75 {
  76         Test *tests = group->handler();
  77         gint i, j, passed = 0, total = 0;
  78         gdouble start_time_group, start_time_test;
  79         gchar **tests_to_run = NULL;
  80
  81         if(!quiet) {
  82                 if(iterations > 1) {
  83                         printf("[%s] (%dx)\n", group->name, iterations);
  84                 } else {
  85                         printf("[%s]\n", group->name);
  86                 }
  87         }
  88
  89         if(tests_to_run_s != NULL) {
  90                 tests_to_run = eg_strsplit(tests_to_run_s, ",", -1);
  91         }
  92
  93         start_time_group = get_timestamp();
  94
  95         for(i = 0; tests[i].name != NULL; i++) {
  96                 gchar *result = "";
  97                 gboolean iter_pass, run;
  98
  99                 iter_pass = FALSE;
 100                 if(tests_to_run != NULL) {
 101                         gint j;
 102                         run = FALSE;
 103                         for(j = 0; tests_to_run[j] != NULL; j++) {
 104                                 if(strcmp(tests_to_run[j], tests[i].name) == 0) {
 105                                         run = TRUE;
 106                                         break;
 107                                 }
 108                         }
 109                 } else {
 110                         run = TRUE;
 111                 }
 112
 113                 if(!run) {
 114                         continue;
 115                 }
 116
 117                 total++;
 118
 119                 if(!quiet) {
 120                         printf("  %s: ", tests[i].name);
 121                 }
 122
 123                 start_time_test = get_timestamp();
 124
 125                 for(j = 0; j < iterations; j++) {
 126                         iter_pass = run_test(&(tests[i]), &result);
 127                         if(!iter_pass) {
 128                                 break;
 129                         }
 130                 }
 131
 132                 if(iter_pass) {
 133                         passed++;
 134                         if(!quiet) {
 135                                 if(time) {
 136                                         printf("OK (%g)\n", get_timestamp() - start_time_test);
 137                                 } else {
 138                                         printf("OK\n");
 139                                 }
 140                         }
 141                 } else  {
 142                         if(!quiet) {
 143                                 printf("FAILED (%s)\n", result);
 144                         }
 145
 146                         if(last_result == result) {
 147                                 last_result = NULL;
 148                                 g_free(result);
 149                         }
 150                 }
 151         }
 152
 153         global_passed += passed;
 154         global_tests += total;
 155
 156         if(!quiet) {
 157                 gdouble pass_percentage = ((gdouble)passed / (gdouble)total) * 100.0;
 158                 if(time) {
 159                         printf("  %d / %d (%g%%, %g)\n", passed, total,
 160                                 pass_percentage, get_timestamp() - start_time_group);
 161                 } else {
 162                         printf("  %d / %d (%g%%)\n", passed, total, pass_percentage);
 163                 }
 164         }
 165
 166         if(tests_to_run != NULL) {
 167                 eg_strfreev(tests_to_run);
 168         }
 169
 170         return passed == total;
 171 }
 172
 173 RESULT
 174 FAILED(const gchar *format, ...)
 175 {
 176         gchar *ret;
 177         va_list args;
 178         gint n;
 179
 180 #if !defined(HAVE_VASPRINTF) && !defined(_EGLIB_MAJOR)
 181         /* We are linked against the real glib, no vasprintf */
 182         g_assert_not_reached ();
 183         return NULL;
 184 #else
 185         va_start(args, format);
 186         n = vasprintf(&ret, format, args);
 187         va_end(args);
 188
 189         if(n == -1) {
 190                 last_result = NULL;
 191                 return NULL;
 192         }
 193
 194         last_result = ret;
 195         return ret;
 196 #endif
 197 }
 198
 199 gdouble
 200 get_timestamp()
 201 {
 202         /* FIXME: We should use g_get_current_time here */
 203         GTimeVal res;
 204         g_get_current_time (&res);
 205         return res.tv_sec + (1.e-6) * res.tv_usec;
 206 }
 207
 208 /*
 209  * Duplicating code here from EGlib to avoid g_strsplit skew between
 210  * EGLib and GLib
 211  */
 212
 213 gchar **
 214 eg_strsplit (const gchar *string, const gchar *delimiter, gint max_tokens)
 215 {
 216         gchar *string_c;
 217         gchar *strtok_save, **vector;
 218         gchar *token, *token_c;
 219         gint size = 1;
 220         size_t token_length;
 221
 222         g_return_val_if_fail(string != NULL, NULL);
 223         g_return_val_if_fail(delimiter != NULL, NULL);
 224         g_return_val_if_fail(delimiter[0] != 0, NULL);
 225
 226         token_length = strlen(string);
 227         string_c = (gchar *)g_malloc(token_length + 1);
 228         memcpy(string_c, string, token_length);
 229         string_c[token_length] = 0;
 230
 231         vector = NULL;
 232         token = (gchar *)strtok_r(string_c, delimiter, &strtok_save);
 233
 234         while(token != NULL) {
 235                 token_length = strlen(token);
 236                 token_c = (gchar *)g_malloc(token_length + 1);
 237                 memcpy(token_c, token, token_length);
 238                 token_c[token_length] = 0;
 239
 240                 vector = vector == NULL ?
 241                         (gchar **)g_malloc(2 * sizeof(vector)) :
 242                         (gchar **)g_realloc(vector, (size + 1) * sizeof(vector));
 243
 244                 vector[size - 1] = token_c;
 245                 size++;
 246
 247                 if(max_tokens > 0 && size >= max_tokens) {
 248                         if(size > max_tokens) {
 249                                 break;
 250                         }
 251
 252                         token = strtok_save;
 253                 } else {
 254                         token = (gchar *)strtok_r(NULL, delimiter, &strtok_save);
 255                 }
 256         }
 257
 258         if(vector != NULL && size > 0) {
 259                 vector[size - 1] = NULL;
 260         }
 261
 262         g_free(string_c);
 263         string_c = NULL;
 264
 265         return vector;
 266 }
 267
 268 void
 269 eg_strfreev (gchar **str_array)
 270 {
 271         gchar **orig = str_array;
 272         if (str_array == NULL)
 273                 return;
 274         while (*str_array != NULL){
 275                 g_free (*str_array);
 276                 str_array++;
 277         }
 278         g_free (orig);
 279 }
 280
 281
 282