git.oblomov.eu Git - wine/blob - programs/winetest/wtmain.c

   1 /*
   2  * Main routine for Wine C unit tests.
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  * Copyright 2002 Andriy Palamarchuk
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "wine/test.h"
  27 #include "winbase.h"
  28
  29 /* debug level */
  30 int winetest_debug = 1;
  31
  32 /* current platform */
  33 const char *winetest_platform = "windows";
  34
  35 /* report successful tests (BOOL) */
  36 int winetest_report_success = 0;
  37
  38 /* passing arguments around */
  39 static int winetest_argc;
  40 static char** winetest_argv;
  41
  42 struct test
  43 {
  44     const char  *name;
  45     void       (*func)(void);
  46 };
  47
  48 extern const struct test winetest_testlist[];
  49 static const struct test *current_test; /* test currently being run */
  50
  51 static LONG successes;       /* number of successful tests */
  52 static LONG failures;        /* number of failures */
  53 static LONG todo_successes;  /* number of successful tests inside todo block */
  54 static LONG todo_failures;   /* number of failures inside todo block */
  55
  56 /* The following data must be kept track of on a per-thread basis */
  57 typedef struct
  58 {
  59     const char* current_file;        /* file of current check */
  60     int current_line;                /* line of current check */
  61     int todo_level;                  /* current todo nesting level */
  62     int todo_do_loop;
  63 } tls_data;
  64 static DWORD tls_index;
  65
  66 static tls_data* get_tls_data(void)
  67 {
  68     tls_data* data;
  69     DWORD last_error;
  70
  71     last_error=GetLastError();
  72     data=TlsGetValue(tls_index);
  73     if (!data)
  74     {
  75         data=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(tls_data));
  76         TlsSetValue(tls_index,data);
  77     }
  78     SetLastError(last_error);
  79     return data;
  80 }
  81
  82 static void exit_process( int code )
  83 {
  84     fflush( stderr );
  85     ExitProcess( code );
  86 }
  87
  88
  89 /*
  90  * Checks condition.
  91  * Parameters:
  92  *   - condition - condition to check;
  93  *   - msg test description;
  94  *   - file - test application source code file name of the check
  95  *   - line - test application source code file line number of the check
  96  * Return:
  97  *   0 if condition does not have the expected value, 1 otherwise
  98  */
  99 int winetest_ok( int condition, const char *msg, ... )
 100 {
 101     va_list valist;
 102     tls_data* data=get_tls_data();
 103
 104     if (data->todo_level)
 105     {
 106         if (condition)
 107         {
 108             fprintf( stderr, "%s:%d: Test succeeded inside todo block",
 109                      data->current_file, data->current_line );
 110             if (msg && msg[0])
 111             {
 112                 va_start(valist, msg);
 113                 fprintf(stderr,": ");
 114                 vfprintf(stderr, msg, valist);
 115                 va_end(valist);
 116             }
 117             fputc( '\n', stderr );
 118             InterlockedIncrement(&todo_failures);
 119             return 0;
 120         }
 121         else InterlockedIncrement(&todo_successes);
 122     }
 123     else
 124     {
 125         if (!condition)
 126         {
 127             fprintf( stderr, "%s:%d: Test failed",
 128                      data->current_file, data->current_line );
 129             if (msg && msg[0])
 130             {
 131                 va_start(valist, msg);
 132                 fprintf( stderr,": ");
 133                 vfprintf(stderr, msg, valist);
 134                 va_end(valist);
 135             }
 136             fputc( '\n', stderr );
 137             InterlockedIncrement(&failures);
 138             return 0;
 139         }
 140         else
 141         {
 142             if( winetest_report_success)
 143                 fprintf( stderr, "%s:%d: Test succeeded\n",
 144                          data->current_file, data->current_line);
 145             InterlockedIncrement(&successes);
 146         }
 147     }
 148     return 1;
 149 }
 150
 151 winetest_ok_funcptr winetest_set_ok_location( const char* file, int line )
 152 {
 153     tls_data* data=get_tls_data();
 154     data->current_file=file;
 155     data->current_line=line;
 156     return &winetest_ok;
 157 }
 158
 159 void winetest_trace( const char *msg, ... )
 160 {
 161     va_list valist;
 162     tls_data* data=get_tls_data();
 163
 164     if (winetest_debug > 0)
 165     {
 166         fprintf( stderr, "%s:%d:", data->current_file, data->current_line );
 167         va_start(valist, msg);
 168         vfprintf(stderr, msg, valist);
 169         va_end(valist);
 170     }
 171 }
 172
 173 winetest_trace_funcptr winetest_set_trace_location( const char* file, int line )
 174 {
 175     tls_data* data=get_tls_data();
 176     data->current_file=file;
 177     data->current_line=line;
 178     return &winetest_trace;
 179 }
 180
 181 void winetest_start_todo( const char* platform )
 182 {
 183     tls_data* data=get_tls_data();
 184     if (strcmp(winetest_platform,platform)==0)
 185         data->todo_level++;
 186     data->todo_do_loop=1;
 187 }
 188
 189 int winetest_loop_todo(void)
 190 {
 191     tls_data* data=get_tls_data();
 192     int do_loop=data->todo_do_loop;
 193     data->todo_do_loop=0;
 194     return do_loop;
 195 }
 196
 197 void winetest_end_todo( const char* platform )
 198 {
 199     if (strcmp(winetest_platform,platform)==0)
 200     {
 201         tls_data* data=get_tls_data();
 202         data->todo_level--;
 203     }
 204 }
 205
 206 int winetest_get_mainargs( char*** pargv )
 207 {
 208     *pargv = winetest_argv;
 209     return winetest_argc;
 210 }
 211
 212 /* Find a test by name */
 213 static const struct test *find_test( const char *name )
 214 {
 215     const struct test *test;
 216     const char *p;
 217     int len;
 218
 219     if ((p = strrchr( name, '/' ))) name = p + 1;
 220     if ((p = strrchr( name, '\\' ))) name = p + 1;
 221     len = strlen(name);
 222     if (len > 2 && !strcmp( name + len - 2, ".c" )) len -= 2;
 223
 224     for (test = winetest_testlist; test->name; test++)
 225     {
 226         if (!strncmp( test->name, name, len ) && !test->name[len]) break;
 227     }
 228     return test->name ? test : NULL;
 229 }
 230
 231
 232 /* Run a named test, and return exit status */
 233 static int run_test( const char *name )
 234 {
 235     const struct test *test;
 236     int status;
 237
 238     if (!(test = find_test( name )))
 239     {
 240         fprintf( stderr, "Fatal: test '%s' does not exist.\n", name );
 241         exit_process(1);
 242     }
 243     successes = failures = todo_successes = todo_failures = 0;
 244     tls_index=TlsAlloc();
 245     current_test = test;
 246     test->func();
 247
 248     if (winetest_debug)
 249     {
 250         fprintf( stderr, "%s: %ld tests executed, %ld marked as todo, %ld %s.\n",
 251                  name, successes + failures + todo_successes + todo_failures,
 252                  todo_successes, failures + todo_failures,
 253                  (failures + todo_failures != 1) ? "failures" : "failure" );
 254     }
 255     status = (failures + todo_failures < 255) ? failures + todo_failures : 255;
 256     return status;
 257 }
 258
 259
 260 /* Display usage and exit */
 261 static void usage( const char *argv0 )
 262 {
 263     const struct test *test;
 264
 265     fprintf( stderr, "Usage: %s test_name\n", argv0 );
 266     fprintf( stderr, "\nValid test names:\n" );
 267     for (test = winetest_testlist; test->name; test++) fprintf( stderr, "    %s\n", test->name );
 268     exit_process(1);
 269 }
 270
 271
 272 /* main function */
 273 int main( int argc, char **argv )
 274 {
 275     char *p;
 276
 277     winetest_argc = argc;
 278     winetest_argv = argv;
 279
 280     if ((p = getenv( "WINETEST_PLATFORM" ))) winetest_platform = p;
 281     if ((p = getenv( "WINETEST_DEBUG" ))) winetest_debug = atoi(p);
 282     if ((p = getenv( "WINETEST_REPORT_SUCCESS"))) winetest_report_success = \
 283                 atoi(p);
 284     if (!argv[1]) usage( argv[0] );
 285
 286     return run_test(argv[1]);
 287 }