ReactOS  0.4.14-dev-606-g14ebc0b
test.h
Go to the documentation of this file.
1 /*
2  * Definitions for Wine C unit tests.
3  *
4  * Copyright (C) 2002 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20 
21 #ifndef __WINE_WINE_TEST_H
22 #define __WINE_WINE_TEST_H
23 
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #include <windef.h>
27 #include <winbase.h>
28 
29 #ifdef __WINE_CONFIG_H
30 #error config.h should not be used in Wine tests
31 #endif
32 #ifdef __WINE_WINE_LIBRARY_H
33 #error wine/library.h should not be used in Wine tests
34 #endif
35 #ifdef __WINE_WINE_UNICODE_H
36 #error wine/unicode.h should not be used in Wine tests
37 #endif
38 #ifdef __WINE_WINE_DEBUG_H
39 #error wine/debug.h should not be used in Wine tests
40 #endif
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 #ifndef INVALID_FILE_ATTRIBUTES
47 #define INVALID_FILE_ATTRIBUTES (~0u)
48 #endif
49 #ifndef INVALID_SET_FILE_POINTER
50 #define INVALID_SET_FILE_POINTER (~0u)
51 #endif
52 
53 /* debug level */
54 extern int winetest_debug;
55 
56 extern int report_success;
57 
58 /* running in interactive mode? */
59 extern int winetest_interactive;
60 
61 /* current platform */
62 extern const char *winetest_platform;
63 
64 extern void winetest_set_location( const char* file, int line );
65 extern void winetest_start_todo( int is_todo );
66 extern int winetest_loop_todo(void);
67 extern void winetest_end_todo(void);
68 extern int winetest_get_mainargs( char*** pargv );
69 extern LONG winetest_get_failures(void);
70 extern LONG winetest_get_successes(void);
71 extern void winetest_add_failures( LONG new_failures );
77 
78 extern const char *wine_dbgstr_wn( const WCHAR *str, intptr_t n );
79 extern const char *wine_dbgstr_guid( const GUID *guid );
80 extern const char *wine_dbgstr_point( const POINT *guid );
81 extern const char *wine_dbgstr_size( const SIZE *guid );
82 extern const char *wine_dbgstr_rect( const RECT *rect );
83 #ifdef WINETEST_USE_DBGSTR_LONGLONG
84 extern const char *wine_dbgstr_longlong( ULONGLONG ll );
85 #endif
86 static inline const char *wine_dbgstr_w( const WCHAR *s ) { return wine_dbgstr_wn( s, -1 ); }
87 
88 /* strcmpW is available for tests compiled under Wine, but not in standalone
89  * builds under Windows, so we reimplement it under a different name. */
90 static inline int winetest_strcmpW( const WCHAR *str1, const WCHAR *str2 )
91 {
92  while (*str1 && (*str1 == *str2)) { str1++; str2++; }
93  return *str1 - *str2;
94 }
95 
96 #ifdef STANDALONE
97 
98 #define START_TEST(name) \
99  static void func_##name(void); \
100  const struct test winetest_testlist[] = { { #name, func_##name }, { 0, 0 } }; \
101  static void func_##name(void)
102 
103 #else /* STANDALONE */
104 
105 #ifdef __cplusplus
106 #define START_TEST(name) extern "C" void func_##name(void)
107 #else
108 #define START_TEST(name) void func_##name(void)
109 #endif
110 
111 #endif /* STANDALONE */
112 
113 #if defined(__x86_64__) && defined(__GNUC__) && defined(__WINE_USE_MSVCRT)
114 #define __winetest_cdecl __cdecl
115 #define __winetest_va_list __builtin_ms_va_list
116 #else
117 #define __winetest_cdecl
118 #define __winetest_va_list va_list
119 #endif
120 
121 extern int broken( int condition );
122 extern int winetest_vok( int condition, const char *msg, __winetest_va_list ap );
123 extern void winetest_vskip( const char *msg, __winetest_va_list ap );
124 
125 #ifdef __GNUC__
126 # define WINETEST_PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args)))
127 extern void __winetest_cdecl winetest_ok( int condition, const char *msg, ... ) __attribute__((format (printf,2,3) ));
128 extern void __winetest_cdecl winetest_skip( const char *msg, ... ) __attribute__((format (printf,1,2)));
129 extern void __winetest_cdecl winetest_win_skip( const char *msg, ... ) __attribute__((format (printf,1,2)));
130 extern void __winetest_cdecl winetest_trace( const char *msg, ... ) __attribute__((format (printf,1,2)));
131 extern void __winetest_cdecl winetest_print(const char* msg, ...) __attribute__((format(printf, 1, 2)));
132 
133 #else /* __GNUC__ */
134 # define WINETEST_PRINTF_ATTR(fmt,args)
135 extern void __winetest_cdecl winetest_ok( int condition, const char *msg, ... );
136 extern void __winetest_cdecl winetest_skip( const char *msg, ... );
137 extern void __winetest_cdecl winetest_win_skip( const char *msg, ... );
138 extern void __winetest_cdecl winetest_trace( const char *msg, ... );
139 extern void __winetest_cdecl winetest_print(const char* msg, ...);
140 
141 #endif /* __GNUC__ */
142 
143 #define ok_(file, line) (winetest_set_location(file, line), 0) ? (void)0 : winetest_ok
144 #define skip_(file, line) (winetest_set_location(file, line), 0) ? (void)0 : winetest_skip
145 #define win_skip_(file, line) (winetest_set_location(file, line), 0) ? (void)0 : winetest_win_skip
146 #define trace_(file, line) (winetest_set_location(file, line), 0) ? (void)0 : winetest_trace
147 
148 #define ok ok_(__FILE__, __LINE__)
149 #define skip skip_(__FILE__, __LINE__)
150 #define win_skip win_skip_(__FILE__, __LINE__)
151 #define trace trace_(__FILE__, __LINE__)
152 
153 #define todo_if(is_todo) for (winetest_start_todo(is_todo); \
154  winetest_loop_todo(); \
155  winetest_end_todo())
156 
157 #define todo_ros todo_if(!strcmp(winetest_platform, "reactos"))
158 #define todo_ros_if(is_todo) todo_if((is_todo) && !strcmp(winetest_platform, "reactos"))
159 #ifdef USE_WINE_TODOS
160 #define todo_wine todo_ros
161 #define todo_wine_if todo_ros_if
162 #else
163 #define todo_wine todo_if(!strcmp(winetest_platform, "wine"))
164 #define todo_wine_if(is_todo) todo_if((is_todo) && !strcmp(winetest_platform, "wine"))
165 #endif
166 
167 #define ros_skip_flaky for (winetest_print("Skipping flaky test\n");0;)
168 
169 #define disable_success_count for (winetest_disable_success_count_start(); \
170  (winetest_disable_success_count_get() ? \
171  winetest_disable_success_count_end() : \
172  winetest_disable_success_count_set()); \
173  )
174 
175 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
176 
177 #ifdef NONAMELESSUNION
178 # define U(x) (x).u
179 # define U1(x) (x).u1
180 # define U2(x) (x).u2
181 # define U3(x) (x).u3
182 # define U4(x) (x).u4
183 # define U5(x) (x).u5
184 # define U6(x) (x).u6
185 # define U7(x) (x).u7
186 # define U8(x) (x).u8
187 #else
188 # define U(x) (x)
189 # define U1(x) (x)
190 # define U2(x) (x)
191 # define U3(x) (x)
192 # define U4(x) (x)
193 # define U5(x) (x)
194 # define U6(x) (x)
195 # define U7(x) (x)
196 # define U8(x) (x)
197 #endif
198 
199 #ifdef NONAMELESSSTRUCT
200 # define S(x) (x).s
201 # define S1(x) (x).s1
202 # define S2(x) (x).s2
203 # define S3(x) (x).s3
204 # define S4(x) (x).s4
205 # define S5(x) (x).s5
206 #else
207 # define S(x) (x)
208 # define S1(x) (x)
209 # define S2(x) (x)
210 # define S3(x) (x)
211 # define S4(x) (x)
212 # define S5(x) (x)
213 #endif
214 
215 
216 /************************************************************************/
217 /* Below is the implementation of the various functions, to be included
218  * directly into the generated testlist.c file.
219  * It is done that way so that the dlls can build the test routines with
220  * different includes or flags if needed.
221  */
222 
223 #ifdef STANDALONE
224 
225 #include <stdio.h>
226 
227 #if defined(__x86_64__) && defined(__GNUC__) && defined(__WINE_USE_MSVCRT)
228 # define __winetest_va_start(list,arg) __builtin_ms_va_start(list,arg)
229 # define __winetest_va_end(list) __builtin_ms_va_end(list)
230 #else
231 # define __winetest_va_start(list,arg) va_start(list,arg)
232 # define __winetest_va_end(list) va_end(list)
233 #endif
234 
235 /* Define WINETEST_MSVC_IDE_FORMATTING to alter the output format winetest will use for file/line numbers.
236  This alternate format makes the file/line numbers clickable in visual studio, to directly jump to them. */
237 #if defined(WINETEST_MSVC_IDE_FORMATTING)
238 # define __winetest_file_line_prefix "%s(%d)"
239 #else
240 # define __winetest_file_line_prefix "%s:%d"
241 #endif
242 
243 struct test
244 {
245  const char *name;
246  void (*func)(void);
247 };
248 
249 extern const struct test winetest_testlist[];
250 
251 /* debug level */
252 int winetest_debug = 1;
253 
254 /* interactive mode? */
255 int winetest_interactive = 0;
256 
257 /* current platform */
258 const char *winetest_platform = "windows";
259 
260 /* report successful tests (BOOL) */
261 int report_success = 0;
262 
263 /* passing arguments around */
264 static int winetest_argc;
265 static char** winetest_argv;
266 
267 static const struct test *current_test; /* test currently being run */
268 
269 static LONG successes; /* number of successful tests */
270 static LONG failures; /* number of failures */
271 static LONG skipped; /* number of skipped test chunks */
272 static LONG todo_successes; /* number of successful tests inside todo block */
273 static LONG todo_failures; /* number of failures inside todo block */
274 
275 /* The following data must be kept track of on a per-thread basis */
276 typedef struct
277 {
278  const char* current_file; /* file of current check */
279  int current_line; /* line of current check */
280  unsigned int todo_level; /* current todo nesting level */
281  unsigned int nocount_level;
282  int todo_do_loop;
283  char *str_pos; /* position in debug buffer */
284  char strings[2000]; /* buffer for debug strings */
285 } tls_data;
286 static DWORD tls_index;
287 
288 static tls_data* get_tls_data(void)
289 {
290  tls_data* data;
292 
294  data=(tls_data*)TlsGetValue(tls_index);
295  if (!data)
296  {
297  data=(tls_data*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(tls_data));
298  data->str_pos = data->strings;
300  }
302  return data;
303 }
304 
305 /* allocate some tmp space for a string */
306 static char *get_temp_buffer( size_t n )
307 {
308  tls_data *data = get_tls_data();
309  char *res = data->str_pos;
310 
311  if (res + n >= &data->strings[sizeof(data->strings)]) res = data->strings;
312  data->str_pos = res + n;
313  return res;
314 }
315 
316 /* release extra space that we requested in gimme1() */
317 static void release_temp_buffer( char *ptr, size_t size )
318 {
319  tls_data *data = get_tls_data();
320  data->str_pos = ptr + size;
321 }
322 
323 static void exit_process( int code )
324 {
325  fflush( stdout );
326  ExitProcess( code );
327 }
328 
329 
330 void winetest_set_location( const char* file, int line )
331 {
332  tls_data* data=get_tls_data();
333 #if defined(WINETEST_MSVC_IDE_FORMATTING)
334  data->current_file = file;
335 #else
336  data->current_file=strrchr(file,'/');
337  if (data->current_file==NULL)
338  data->current_file=strrchr(file,'\\');
339  if (data->current_file==NULL)
340  data->current_file=file;
341  else
342  data->current_file++;
343 #endif
344  data->current_line=line;
345 }
346 
347 int broken( int condition )
348 {
349  return ((strcmp(winetest_platform, "windows") == 0)
350 #ifndef USE_WINE_TODOS
351  || (strcmp(winetest_platform, "reactos") == 0)
352 #endif
353  ) && condition;
354 }
355 
356 /*
357  * Checks condition.
358  * Parameters:
359  * - condition - condition to check;
360  * - msg test description;
361  * - file - test application source code file name of the check
362  * - line - test application source code file line number of the check
363  * Return:
364  * 0 if condition does not have the expected value, 1 otherwise
365  */
366 int winetest_vok( int condition, const char *msg, __winetest_va_list args )
367 {
368  tls_data* data=get_tls_data();
369 
370  if (data->todo_level)
371  {
372  if (condition)
373  {
374  fprintf( stdout, __winetest_file_line_prefix ": Test succeeded inside todo block: ",
375  data->current_file, data->current_line );
376  vfprintf(stdout, msg, args);
377  InterlockedIncrement(&todo_failures);
378  return 0;
379  }
380  else
381  {
382  /* show todos even if traces are disabled*/
383  /*if (winetest_debug > 0)*/
384  {
385  fprintf( stdout, __winetest_file_line_prefix ": Test marked todo: ",
386  data->current_file, data->current_line );
387  vfprintf(stdout, msg, args);
388  }
389  if (data->nocount_level == 0)
390  InterlockedIncrement(&todo_successes);
391  return 1;
392  }
393  }
394  else
395  {
396  if (!condition)
397  {
398  fprintf( stdout, __winetest_file_line_prefix ": Test failed: ",
399  data->current_file, data->current_line );
400  vfprintf(stdout, msg, args);
401  InterlockedIncrement(&failures);
402  return 0;
403  }
404  else
405  {
406  if (report_success && data->nocount_level == 0)
407  fprintf( stdout, __winetest_file_line_prefix ": Test succeeded\n",
408  data->current_file, data->current_line);
409  if (data->nocount_level == 0)
410  InterlockedIncrement(&successes);
411  return 1;
412  }
413  }
414 }
415 
416 void __winetest_cdecl winetest_ok( int condition, const char *msg, ... )
417 {
419 
420  __winetest_va_start(valist, msg);
422  __winetest_va_end(valist);
423 }
424 
425 void __winetest_cdecl winetest_trace( const char *msg, ... )
426 {
428  tls_data* data=get_tls_data();
429 
430  if (winetest_debug > 0)
431  {
432  fprintf( stdout, __winetest_file_line_prefix ": ", data->current_file, data->current_line );
433  __winetest_va_start(valist, msg);
435  __winetest_va_end(valist);
436  }
437 }
438 
439 void __winetest_cdecl winetest_print(const char* msg, ...)
440 {
442  tls_data* data = get_tls_data();
443 
444  fprintf(stdout, __winetest_file_line_prefix ": ", data->current_file, data->current_line);
445  __winetest_va_start(valist, msg);
447  __winetest_va_end(valist);
448 }
449 
450 void winetest_vskip( const char *msg, __winetest_va_list args )
451 {
452  tls_data* data=get_tls_data();
453 
454  fprintf( stdout, __winetest_file_line_prefix ": Tests skipped: ", data->current_file, data->current_line );
455  vfprintf(stdout, msg, args);
456  skipped++;
457 }
458 
459 void __winetest_cdecl winetest_skip( const char *msg, ... )
460 {
462  __winetest_va_start(valist, msg);
464  __winetest_va_end(valist);
465 }
466 
467 void __winetest_cdecl winetest_win_skip( const char *msg, ... )
468 {
470  __winetest_va_start(valist, msg);
471  if ((strcmp(winetest_platform, "windows") == 0)
472 #ifndef USE_WINE_TODOS
473  || (strcmp(winetest_platform, "reactos") == 0)
474 #endif
475  )
477  else
478  winetest_vok(0, msg, valist);
479  __winetest_va_end(valist);
480 }
481 
482 void winetest_start_todo( int is_todo )
483 {
484  tls_data* data=get_tls_data();
485  data->todo_level = (data->todo_level << 1) | (is_todo != 0);
486  data->todo_do_loop=1;
487 }
488 
489 int winetest_loop_todo(void)
490 {
491  tls_data* data=get_tls_data();
492  int do_loop=data->todo_do_loop;
493  data->todo_do_loop=0;
494  return do_loop;
495 }
496 
497 void winetest_end_todo(void)
498 {
499  tls_data* data=get_tls_data();
500  data->todo_level >>= 1;
501 }
502 
503 int winetest_get_mainargs( char*** pargv )
504 {
505  *pargv = winetest_argv;
506  return winetest_argc;
507 }
508 
510 {
511  return failures;
512 }
513 
515 {
516  return successes;
517 }
518 
519 void winetest_add_failures( LONG new_failures )
520 {
521  while (new_failures-- > 0)
522  InterlockedIncrement( &failures );
523 }
524 
526 {
527  DWORD exit_code = 1;
528 
529  if (WaitForSingleObject( process, 30000 ))
530  fprintf( stdout, "%s: child process wait failed\n", current_test->name );
531  else
533 
534  if (exit_code)
535  {
536  if (exit_code > 255)
537  {
538  fprintf( stdout, "%s: exception 0x%08x in child process\n", current_test->name, (unsigned)exit_code );
539  InterlockedIncrement( &failures );
540  }
541  else
542  {
543  fprintf( stdout, "%s: %u failures in child process\n",
544  current_test->name, (unsigned)exit_code );
545  while (exit_code-- > 0)
546  InterlockedIncrement(&failures);
547  }
548  }
549 }
550 
552 {
553  get_tls_data()->nocount_level <<= 1;
554 }
555 
557 {
558  get_tls_data()->nocount_level >>= 1;
559  return 0;
560 }
561 
563 {
564  return get_tls_data()->nocount_level & 1;
565 }
566 
568 {
569  get_tls_data()->nocount_level |= 1;
570  return 1;
571 }
572 
573 const char *wine_dbgstr_wn( const WCHAR *str, intptr_t n )
574 {
575  char *dst, *res;
576  size_t size;
577 
578  if (!((ULONG_PTR)str >> 16))
579  {
580  if (!str) return "(null)";
581  res = get_temp_buffer( 6 );
582  sprintf( res, "#%04x", LOWORD(str) );
583  return res;
584  }
585  if (n == -1)
586  {
587  const WCHAR *end = str;
588  while (*end) end++;
589  n = end - str;
590  }
591  if (n < 0) n = 0;
592  size = 12 + min( 300, n * 5 );
593  dst = res = get_temp_buffer( size );
594  *dst++ = 'L';
595  *dst++ = '"';
596  while (n-- > 0 && dst <= res + size - 10)
597  {
598  WCHAR c = *str++;
599  switch (c)
600  {
601  case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
602  case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
603  case '\t': *dst++ = '\\'; *dst++ = 't'; break;
604  case '"': *dst++ = '\\'; *dst++ = '"'; break;
605  case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
606  default:
607  if (c >= ' ' && c <= 126)
608  *dst++ = (char)c;
609  else
610  {
611  *dst++ = '\\';
612  sprintf(dst,"%04x",c);
613  dst+=4;
614  }
615  }
616  }
617  *dst++ = '"';
618  if (n > 0)
619  {
620  *dst++ = '.';
621  *dst++ = '.';
622  *dst++ = '.';
623  }
624  *dst++ = 0;
626  return res;
627 }
628 
629 const char *wine_dbgstr_guid( const GUID *guid )
630 {
631  char *res;
632 
633  if (!guid) return "(null)";
634  res = get_temp_buffer( 39 ); /* CHARS_IN_GUID */
635  sprintf( res, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
636  guid->Data1, guid->Data2, guid->Data3, guid->Data4[0],
637  guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4],
638  guid->Data4[5], guid->Data4[6], guid->Data4[7] );
639  return res;
640 }
641 
642 const char *wine_dbgstr_point( const POINT *point )
643 {
644  char *res;
645 
646  if (!point) return "(null)";
647  res = get_temp_buffer( 60 );
648 #ifdef __ROS_LONG64__
649  sprintf( res, "(%d,%d)", point->x, point->y );
650 #else
651  sprintf( res, "(%ld,%ld)", point->x, point->y );
652 #endif
654  return res;
655 }
656 
657 const char *wine_dbgstr_size( const SIZE *size )
658 {
659  char *res;
660 
661  if (!size) return "(null)";
662  res = get_temp_buffer( 60 );
663 #ifdef __ROS_LONG64__
664  sprintf( res, "(%d,%d)", size->cx, size->cy );
665 #else
666  sprintf( res, "(%ld,%ld)", size->cx, size->cy );
667 #endif
669  return res;
670 }
671 
672 const char *wine_dbgstr_rect( const RECT *rect )
673 {
674  char *res;
675 
676  if (!rect) return "(null)";
677  res = get_temp_buffer( 60 );
678 #ifdef __ROS_LONG64__
679  sprintf( res, "(%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
680 #else
681  sprintf( res, "(%ld,%ld)-(%ld,%ld)", rect->left, rect->top, rect->right, rect->bottom );
682 #endif
684  return res;
685 }
686 
687 #ifdef WINETEST_USE_DBGSTR_LONGLONG
688 const char *wine_dbgstr_longlong( ULONGLONG ll )
689 {
690  char *res;
691 
692  res = get_temp_buffer( 20 );
693  if (/*sizeof(ll) > sizeof(unsigned long) &&*/ ll >> 32) /* ULONGLONG is always > long in ReactOS */
694  sprintf( res, "%lx%08lx", (unsigned long)(ll >> 32), (unsigned long)ll );
695  else
696  sprintf( res, "%lx", (unsigned long)ll );
698  return res;
699 }
700 #endif
701 
702 /* Find a test by name */
703 static const struct test *find_test( const char *name )
704 {
705  const struct test *test;
706  const char *p;
707  size_t len;
708 
709  if ((p = strrchr( name, '/' ))) name = p + 1;
710  if ((p = strrchr( name, '\\' ))) name = p + 1;
711  len = strlen(name);
712  if (len > 2 && !strcmp( name + len - 2, ".c" )) len -= 2;
713 
714  for (test = winetest_testlist; test->name; test++)
715  {
716  if (!strncmp( test->name, name, len ) && !test->name[len]) break;
717  }
718  return test->name ? test : NULL;
719 }
720 
721 
722 /* Display list of valid tests */
723 static void list_tests(void)
724 {
725  const struct test *test;
726 
727  fprintf( stdout, "Valid test names:\n" );
728  for (test = winetest_testlist; test->name; test++) fprintf( stdout, " %s\n", test->name );
729 }
730 
731 /* Disable false-positive claiming "test" would be NULL-dereferenced */
732 #if defined(_MSC_VER)
733 #pragma warning(push)
734 #pragma warning(disable:28182)
735 #endif
736 
737 /* Run a named test, and return exit status */
738 static int run_test( const char *name )
739 {
740  const struct test *test;
741  int status;
742 
743  if (!(test = find_test( name )))
744  {
745  fprintf( stdout, "Fatal: test '%s' does not exist.\n", name );
746  exit_process(1);
747  }
748  successes = failures = todo_successes = todo_failures = 0;
750  current_test = test;
751  test->func();
752 
753  /* show test results even if traces are disabled */
754  /*if (winetest_debug)*/
755  {
756  fprintf( stdout, "\n%s: %d tests executed (%d marked as todo, %d %s), %d skipped.\n",
757  test->name, (int)(successes + failures + todo_successes + todo_failures),
758  (int)todo_successes, (int)(failures + todo_failures),
759  (failures + todo_failures != 1) ? "failures" : "failure",
760  (int)skipped );
761  }
762  status = (failures + todo_failures < 255) ? failures + todo_failures : 255;
763  return status;
764 }
765 
766 #if defined(_MSC_VER)
767 #pragma warning(pop)
768 #endif
769 
770 /* Display usage and exit */
771 static void usage( const char *argv0 )
772 {
773  fprintf( stdout, "Usage: %s test_name\n\n", argv0 );
774  list_tests();
775  exit_process(1);
776 }
777 
778 
779 /* main function */
780 int main( int argc, char **argv )
781 {
782  char p[128];
783 
784  setvbuf (stdout, NULL, _IONBF, 0);
785 
786  winetest_argc = argc;
787  winetest_argv = argv;
788 
789  if (GetEnvironmentVariableA( "WINETEST_PLATFORM", p, sizeof(p) )) winetest_platform = _strdup(p);
790  if (GetEnvironmentVariableA( "WINETEST_DEBUG", p, sizeof(p) )) winetest_debug = atoi(p);
791  if (GetEnvironmentVariableA( "WINETEST_INTERACTIVE", p, sizeof(p) )) winetest_interactive = atoi(p);
792  if (GetEnvironmentVariableA( "WINETEST_REPORT_SUCCESS", p, sizeof(p) )) report_success = atoi(p);
793 
795 
796  if (!argv[1])
797  {
798  if (winetest_testlist[0].name && !winetest_testlist[1].name) /* only one test */
799  return run_test( winetest_testlist[0].name );
800  usage( argv[0] );
801  }
802  if (!strcmp( argv[1], "--list" ))
803  {
804  list_tests();
805  return 0;
806  }
807  return run_test(argv[1]);
808 }
809 
810 #endif /* STANDALONE */
811 
812 // hack for ntdll winetest (this is defined in excpt.h)
813 #undef exception_info
814 
815 // Some helpful definitions
816 
817 #define ok_hex(expression, result) \
818  do { \
819  int _value = (expression); \
820  ok(_value == (result), "Wrong value for '%s', expected: " #result " (0x%x), got: 0x%x\n", \
821  #expression, (int)(result), _value); \
822  } while (0)
823 
824 #define ok_dec(expression, result) \
825  do { \
826  int _value = (expression); \
827  ok(_value == (result), "Wrong value for '%s', expected: " #result " (%d), got: %d\n", \
828  #expression, (int)(result), _value); \
829  } while (0)
830 
831 #define ok_ptr(expression, result) \
832  do { \
833  void *_value = (expression); \
834  ok(_value == (result), "Wrong value for '%s', expected: " #result " (%p), got: %p\n", \
835  #expression, (void*)(result), _value); \
836  } while (0)
837 
838 #define ok_size_t(expression, result) \
839  do { \
840  size_t _value = (expression); \
841  ok(_value == (result), "Wrong value for '%s', expected: " #result " (%Ix), got: %Ix\n", \
842  #expression, (size_t)(result), _value); \
843  } while (0)
844 
845 #define ok_char(expression, result) ok_hex(expression, result)
846 
847 #define ok_err(error) \
848  ok(GetLastError() == (error), "Wrong last error. Expected " #error ", got 0x%lx\n", GetLastError())
849 
850 #define ok_str(x, y) \
851  ok(strcmp(x, y) == 0, "Wrong string. Expected '%s', got '%s'\n", y, x)
852 
853 #define ok_wstr(x, y) \
854  ok(wcscmp(x, y) == 0, "Wrong string. Expected '%S', got '%S'\n", y, x)
855 
856 #define ok_long(expression, result) ok_hex(expression, result)
857 #define ok_int(expression, result) ok_dec(expression, result)
858 #define ok_ntstatus(status, expected) ok_hex(status, expected)
859 #define ok_hdl ok_ptr
860 
861 #ifdef __cplusplus
862 } /* extern "C" */
863 #endif
864 
865 #endif /* __WINE_WINE_TEST_H */
GLenum func
Definition: glext.h:6028
UINT WINAPI SetErrorMode(IN UINT uMode)
Definition: except.c:753
static int argc
Definition: ServiceArgs.c:12
LONG winetest_get_failures(void)
void winetest_add_failures(LONG new_failures)
int winetest_vok(int condition, const char *msg, __winetest_va_list ap)
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define SEM_FAILCRITICALERRORS
Definition: rtltypes.h:69
void __winetest_cdecl winetest_print(const char *msg,...)
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
BOOL WINAPI TlsSetValue(IN DWORD Index, IN LPVOID Value)
Definition: thread.c:1264
BOOL WINAPI GetExitCodeProcess(IN HANDLE hProcess, IN LPDWORD lpExitCode)
Definition: proc.c:1168
int main(int argc, char *argv[])
Definition: atactl.cpp:1685
GLdouble n
Definition: glext.h:7729
static char * get_temp_buffer(int size)
Definition: registry.c:62
const char * wine_dbgstr_guid(const GUID *guid)
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1487
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define test
Definition: rosglue.h:37
GLuint GLuint end
Definition: gl.h:1545
int winetest_interactive
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define argv
Definition: mplay32.c:18
#define _strdup
Definition: debug_ros.c:7
Definition: match.c:390
#define __winetest_va_list
Definition: test.h:118
int winetest_debug
POINTL point
Definition: edittest.c:50
& rect
Definition: startmenu.cpp:1413
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
FILE * stdout
LONG y
Definition: windef.h:330
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define sprintf(buf, format,...)
Definition: sprintf.c:55
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
int report_success
const GUID * guid
int winetest_disable_success_count_end()
long LONG
Definition: pedump.c:60
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
int winetest_loop_todo(void)
static PVOID ptr
Definition: dispmode.c:27
void winetest_start_todo(int is_todo)
const struct test winetest_testlist[]
Definition: testlist.c:24
GLenum condition
Definition: glext.h:9255
const WCHAR * str
void winetest_end_todo(void)
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
void winetest_vskip(const char *msg, __winetest_va_list ap)
static int winetest_strcmpW(const WCHAR *str1, const WCHAR *str2)
Definition: test.h:90
#define run_test(info, expect_button, expect_radio_button, verification_checked, seq, context)
Definition: taskdialog.c:395
Definition: parser.c:48
TCHAR str_pos[MAX_LOADSTRING]
Definition: sndrec32.cpp:58
const char * winetest_platform
static UINT exit_code
Definition: process.c:78
void __winetest_cdecl winetest_trace(const char *msg,...)
#define __winetest_cdecl
Definition: test.h:117
const char * wine_dbgstr_point(const POINT *guid)
int winetest_disable_success_count_get()
GLsizeiptr size
Definition: glext.h:5919
void winetest_disable_success_count_start()
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define GetEnvironmentVariableA(x, y, z)
Definition: compat.h:419
static const char * wine_dbgstr_w(const WCHAR *s)
Definition: test.h:86
int intptr_t
Definition: crtdefs.h:283
__wchar_t WCHAR
Definition: xmlstorage.h:180
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
uint64_t ULONGLONG
Definition: typedefs.h:65
const char file[]
Definition: icontest.c:11
const GLubyte * c
Definition: glext.h:8905
const char * wine_dbgstr_rect(const RECT *rect)
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
char * name
Definition: compiler.c:66
unsigned long DWORD
Definition: ntddk_ex.h:95
LONG x
Definition: windef.h:329
#define SetLastError(x)
Definition: compat.h:417
int winetest_disable_success_count_set()
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int winetest_get_mainargs(char ***pargv)
GLsizei const GLchar *const * strings
Definition: glext.h:7622
char line[200]
Definition: main.c:97
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
GLenum GLsizei len
Definition: glext.h:6722
static char argv0[MAX_PATH]
Definition: shlexec.c:56
GLdouble s
Definition: gl.h:2039
DWORD WINAPI TlsAlloc(VOID)
Definition: thread.c:1088
static INT do_loop(const PropSheetInfo *psInfo)
Definition: propsheet.c:2790
#define SEM_NOGPFAULTERRORBOX
Definition: rtltypes.h:70
static void release_temp_buffer(char *buffer, size_t size)
Definition: debug.c:350
void winetest_wait_child_process(HANDLE process)
#define InterlockedIncrement
Definition: armddk.h:53
_Check_return_opt_ _CRTIMP int __cdecl fflush(_Inout_opt_ FILE *_File)
GLenum GLenum dst
Definition: glext.h:6340
const char * wine_dbgstr_size(const SIZE *guid)
w ll
Definition: byte_order.h:166
#define min(a, b)
Definition: monoChain.cc:55
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
LPVOID WINAPI TlsGetValue(IN DWORD Index)
Definition: thread.c:1228
#define msg(x)
Definition: auth_time.c:54
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
LONG winetest_get_successes(void)
Definition: name.c:38
void int int ULONGLONG int va_list * ap
Definition: winesup.h:32
GLuint res
Definition: glext.h:9613
void __winetest_cdecl winetest_skip(const char *msg,...)
#define const
Definition: zconf.h:230
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
void __winetest_cdecl winetest_win_skip(const char *msg,...)
_Check_return_opt_ _CRTIMP int __cdecl setvbuf(_Inout_ FILE *_File, _Inout_updates_opt_z_(_Size) char *_Buf, _In_ int _Mode, _In_ size_t _Size)
static __ms_va_list valist
Definition: printf.c:64
#define _IONBF
Definition: stdio.h:130
const char * wine_dbgstr_wn(const WCHAR *str, intptr_t n)
Definition: compat.c:342
int broken(int condition)
GLfloat GLfloat p
Definition: glext.h:8902
tls_data_t * get_tls_data(void)
Definition: urlmon_main.c:62
_Check_return_opt_ _CRTIMP int __cdecl vfprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format, va_list _ArgList)
static SERVICE_STATUS status
Definition: service.c:31
#define LOWORD(l)
Definition: pedump.c:82
DWORD tls_index
#define printf
Definition: config.h:203
void winetest_set_location(const char *file, int line)
Definition: fci.c:126
Definition: ps.c:97
GLuint const GLchar * name
Definition: glext.h:6031