include/private/vkd3d_test.h

   1 /*
   2  * Copyright 2016 Józef Kucia for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __VKD3D_TEST_H
  20 #define __VKD3D_TEST_H
  21
  22 #include "vkd3d_common.h"
  23 #include <assert.h>
  24 #include <inttypes.h>
  25 #include <stdarg.h>
  26 #include <stdbool.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 extern const char *vkd3d_test_name;
  32 extern const char *vkd3d_test_platform;
  33
  34 static void vkd3d_test_start_todo(bool is_todo);
  35 static int vkd3d_test_loop_todo(void);
  36 static void vkd3d_test_end_todo(void);
  37
  38 #define START_TEST(name) \
  39         const char *vkd3d_test_name = #name; \
  40         static void vkd3d_test_main(int argc, char **argv)
  41
  42 /*
  43  * Use assert_that() for conditions that should always be true.
  44  * todo_if() and bug_if() do not influence assert_that().
  45  */
  46 #define assert_that assert_that_(__FILE__, __LINE__)
  47
  48 #define ok ok_(__FILE__, __LINE__)
  49
  50 #define skip skip_(__FILE__, __LINE__)
  51
  52 #define trace trace_(__FILE__, __LINE__)
  53
  54 #define assert_that_(file, line) \
  55         do { \
  56         const char *vkd3d_file = file; \
  57         unsigned int vkd3d_line = line; \
  58         VKD3D_TEST_ASSERT_THAT
  59
  60 #define VKD3D_TEST_ASSERT_THAT(...) \
  61         vkd3d_test_assert_that(vkd3d_file, vkd3d_line, __VA_ARGS__); } while (0)
  62
  63 #define ok_(file, line) \
  64         do { \
  65         const char *vkd3d_file = file; \
  66         unsigned int vkd3d_line = line; \
  67         VKD3D_TEST_OK
  68
  69 #define VKD3D_TEST_OK(...) \
  70         vkd3d_test_ok(vkd3d_file, vkd3d_line, __VA_ARGS__); } while (0)
  71
  72 #define todo_(file, line) \
  73         do { \
  74         const char *vkd3d_file = file; \
  75         unsigned int vkd3d_line = line; \
  76         VKD3D_TEST_TODO
  77
  78 #define VKD3D_TEST_TODO(...) \
  79         vkd3d_test_todo(vkd3d_file, vkd3d_line, __VA_ARGS__); } while (0)
  80
  81 #define skip_(file, line) \
  82         do { \
  83         const char *vkd3d_file = file; \
  84         unsigned int vkd3d_line = line; \
  85         VKD3D_TEST_SKIP
  86
  87 #define VKD3D_TEST_SKIP(...) \
  88         vkd3d_test_skip(vkd3d_file, vkd3d_line, __VA_ARGS__); } while (0)
  89
  90 #define trace_(file, line) \
  91         do { \
  92         const char *vkd3d_file = file; \
  93         unsigned int vkd3d_line = line; \
  94         VKD3D_TEST_TRACE
  95
  96 #define VKD3D_TEST_TRACE(...) \
  97         vkd3d_test_trace(vkd3d_file, vkd3d_line, __VA_ARGS__); } while (0)
  98
  99 #define todo_if(is_todo) \
 100     for (vkd3d_test_start_todo(is_todo); vkd3d_test_loop_todo(); vkd3d_test_end_todo())
 101
 102 #define bug_if(is_bug) \
 103     for (vkd3d_test_start_bug(is_bug); vkd3d_test_loop_bug(); vkd3d_test_end_bug())
 104
 105 #define todo todo_if(true)
 106
 107 struct vkd3d_test_state
 108 {
 109     unsigned int success_count;
 110     unsigned int failure_count;
 111     unsigned int skip_count;
 112     unsigned int todo_count;
 113     unsigned int todo_success_count;
 114     unsigned int bug_count;
 115
 116     unsigned int debug_level;
 117
 118     unsigned int todo_level;
 119     bool todo_do_loop;
 120
 121     unsigned int bug_level;
 122     bool bug_do_loop;
 123     bool bug_enabled;
 124
 125     const char *test_name_filter;
 126     char context[8][128];
 127     unsigned int context_count;
 128 };
 129 extern struct vkd3d_test_state vkd3d_test_state;
 130
 131 static bool
 132 vkd3d_test_platform_is_windows(void)
 133 {
 134     return !strcmp(vkd3d_test_platform, "windows");
 135 }
 136
 137 static inline bool
 138 broken(bool condition)
 139 {
 140     return condition && vkd3d_test_platform_is_windows();
 141 }
 142
 143 /* basename() is not reentrant, basename_r() is not standard and this simple
 144  * implementation should be enough for us. */
 145 static const char *vkd3d_basename(const char *filename)
 146 {
 147     const char *p;
 148
 149     if ((p = strrchr(filename, '/')))
 150         filename = ++p;
 151     if ((p = strrchr(filename, '\\')))
 152         filename = ++p;
 153
 154     return filename;
 155 }
 156
 157 static void vkd3d_test_printf(const char *file, unsigned int line, const char *msg)
 158 {
 159     unsigned int i;
 160
 161     printf("%s:%u: ", vkd3d_basename(file), line);
 162     for (i = 0; i < vkd3d_test_state.context_count; ++i)
 163         printf("%s: ", vkd3d_test_state.context[i]);
 164     printf("%s", msg);
 165 }
 166
 167 static void
 168 vkd3d_test_check_assert_that(const char *file, unsigned int line, bool result, const char *fmt, va_list args)
 169 {
 170     if (result)
 171     {
 172         vkd3d_atomic_increment_u32(&vkd3d_test_state.success_count);
 173         if (vkd3d_test_state.debug_level > 1)
 174             vkd3d_test_printf(file, line, "Test succeeded.\n");
 175     }
 176     else
 177     {
 178         vkd3d_atomic_increment_u32(&vkd3d_test_state.failure_count);
 179         vkd3d_test_printf(file, line, "Test failed: ");
 180         vprintf(fmt, args);
 181     }
 182 }
 183
 184 static void VKD3D_PRINTF_FUNC(4, 5) VKD3D_UNUSED
 185 vkd3d_test_assert_that(const char *file, unsigned int line, bool result, const char *fmt, ...)
 186 {
 187     va_list args;
 188
 189     va_start(args, fmt);
 190     vkd3d_test_check_assert_that(file, line, result, fmt, args);
 191     va_end(args);
 192 }
 193
 194 static void
 195 vkd3d_test_check_ok(const char *file, unsigned int line, bool result, const char *fmt, va_list args)
 196 {
 197     bool is_todo = vkd3d_test_state.todo_level && !vkd3d_test_platform_is_windows();
 198     bool is_bug = vkd3d_test_state.bug_level && !vkd3d_test_platform_is_windows();
 199
 200     if (is_bug && vkd3d_test_state.bug_enabled)
 201     {
 202         vkd3d_atomic_increment_u32(&vkd3d_test_state.bug_count);
 203         if (is_todo)
 204             result = !result;
 205         if (result)
 206             vkd3d_test_printf(file, line, "Fixed bug: ");
 207         else
 208             vkd3d_test_printf(file, line, "Bug: ");
 209         vprintf(fmt, args);
 210     }
 211     else if (is_todo)
 212     {
 213         if (result)
 214         {
 215             vkd3d_atomic_increment_u32(&vkd3d_test_state.todo_success_count);
 216             vkd3d_test_printf(file, line, "Todo succeeded: ");
 217         }
 218         else
 219         {
 220             vkd3d_atomic_increment_u32(&vkd3d_test_state.todo_count);
 221             vkd3d_test_printf(file, line, "Todo: ");
 222         }
 223         vprintf(fmt, args);
 224     }
 225     else
 226     {
 227         vkd3d_test_check_assert_that(file, line, result, fmt, args);
 228     }
 229 }
 230
 231 static void VKD3D_PRINTF_FUNC(4, 5) VKD3D_UNUSED
 232 vkd3d_test_ok(const char *file, unsigned int line, bool result, const char *fmt, ...)
 233 {
 234     va_list args;
 235
 236     va_start(args, fmt);
 237     vkd3d_test_check_ok(file, line, result, fmt, args);
 238     va_end(args);
 239 }
 240
 241 static void VKD3D_PRINTF_FUNC(3, 4) VKD3D_UNUSED
 242 vkd3d_test_skip(const char *file, unsigned int line, const char *fmt, ...)
 243 {
 244     va_list args;
 245     va_start(args, fmt);
 246     vkd3d_test_printf(file, line, "Test skipped: ");
 247     vprintf(fmt, args);
 248     va_end(args);
 249     vkd3d_atomic_increment_u32(&vkd3d_test_state.skip_count);
 250 }
 251
 252 static void VKD3D_PRINTF_FUNC(3, 4) VKD3D_UNUSED
 253 vkd3d_test_trace(const char *file, unsigned int line, const char *fmt, ...)
 254 {
 255     va_list args;
 256     va_start(args, fmt);
 257     vkd3d_test_printf(file, line, "");
 258     vprintf(fmt, args);
 259     va_end(args);
 260 }
 261
 262 static void VKD3D_PRINTF_FUNC(1, 2) VKD3D_UNUSED
 263 vkd3d_test_debug(const char *fmt, ...)
 264 {
 265     char buffer[512];
 266     va_list args;
 267     int size;
 268
 269     size = snprintf(buffer, sizeof(buffer), "%s: ", vkd3d_test_name);
 270     if (0 < size && size < sizeof(buffer))
 271     {
 272         va_start(args, fmt);
 273         vsnprintf(buffer + size, sizeof(buffer) - size, fmt, args);
 274         va_end(args);
 275     }
 276     buffer[sizeof(buffer) - 1] = '\0';
 277
 278 #ifdef _WIN32
 279     OutputDebugStringA(buffer);
 280 #endif
 281
 282     if (vkd3d_test_state.debug_level > 0)
 283         printf("%s\n", buffer);
 284 }
 285
 286 #ifndef VKD3D_TEST_NO_DEFS
 287 const char *vkd3d_test_platform = "other";
 288 struct vkd3d_test_state vkd3d_test_state;
 289
 290 static void vkd3d_test_main(int argc, char **argv);
 291
 292 int main(int argc, char **argv)
 293 {
 294     const char *test_filter = getenv("VKD3D_TEST_FILTER");
 295     const char *debug_level = getenv("VKD3D_TEST_DEBUG");
 296     char *test_platform = getenv("VKD3D_TEST_PLATFORM");
 297     const char *bug = getenv("VKD3D_TEST_BUG");
 298
 299     setvbuf(stdout, NULL, _IONBF, 0);
 300     memset(&vkd3d_test_state, 0, sizeof(vkd3d_test_state));
 301     vkd3d_test_state.debug_level = debug_level ? atoi(debug_level) : 0;
 302     vkd3d_test_state.bug_enabled = bug ? atoi(bug) : true;
 303     vkd3d_test_state.test_name_filter = test_filter;
 304
 305     if (test_platform)
 306     {
 307         test_platform = strdup(test_platform);
 308         vkd3d_test_platform = test_platform;
 309     }
 310
 311     if (vkd3d_test_state.debug_level > 1)
 312         printf("Test platform: '%s'.\n", vkd3d_test_platform);
 313
 314     vkd3d_test_main(argc, argv);
 315
 316     printf("%s: %u tests executed (%u failures, %u skipped, %u todo, %u bugs).\n",
 317             vkd3d_test_name,
 318             vkd3d_test_state.success_count + vkd3d_test_state.failure_count
 319                     + vkd3d_test_state.todo_count + vkd3d_test_state.todo_success_count,
 320             vkd3d_test_state.failure_count + vkd3d_test_state.todo_success_count,
 321             vkd3d_test_state.skip_count,
 322             vkd3d_test_state.todo_count,
 323             vkd3d_test_state.bug_count);
 324
 325     if (test_platform)
 326         free(test_platform);
 327
 328     return vkd3d_test_state.failure_count || vkd3d_test_state.todo_success_count;
 329 }
 330
 331 #ifdef _WIN32
 332 static char *vkd3d_test_strdupWtoA(WCHAR *str)
 333 {
 334     char *out;
 335     int len;
 336
 337     if (!(len = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL)))
 338         return NULL;
 339     if (!(out = malloc(len)))
 340         return NULL;
 341     WideCharToMultiByte(CP_ACP, 0, str, -1, out, len, NULL, NULL);
 342
 343     return out;
 344 }
 345
 346 static bool running_under_wine(void)
 347 {
 348     HMODULE module = GetModuleHandleA("ntdll.dll");
 349     return module && GetProcAddress(module, "wine_server_call");
 350 }
 351
 352 int wmain(int argc, WCHAR **wargv)
 353 {
 354     char **argv;
 355     int i, ret;
 356
 357     argv = malloc(argc * sizeof(*argv));
 358     assert(argv);
 359     for (i = 0; i < argc; ++i)
 360     {
 361         if (!(argv[i] = vkd3d_test_strdupWtoA(wargv[i])))
 362             break;
 363     }
 364     assert(i == argc);
 365
 366     vkd3d_test_platform = running_under_wine() ? "wine" : "windows";
 367
 368     ret = main(argc, argv);
 369
 370     for (i = 0; i < argc; ++i)
 371         free(argv[i]);
 372     free(argv);
 373
 374     return ret;
 375 }
 376 #endif  /* _WIN32 */
 377 #endif /* VKD3D_TEST_NO_DEFS */
 378
 379 typedef void (*vkd3d_test_pfn)(void);
 380
 381 static inline void vkd3d_run_test(const char *name, vkd3d_test_pfn test_pfn)
 382 {
 383     if (vkd3d_test_state.test_name_filter && !strstr(name, vkd3d_test_state.test_name_filter))
 384         return;
 385
 386     vkd3d_test_debug("%s", name);
 387     test_pfn();
 388 }
 389
 390 static inline void vkd3d_test_start_todo(bool is_todo)
 391 {
 392     vkd3d_test_state.todo_level = (vkd3d_test_state.todo_level << 1) | is_todo;
 393     vkd3d_test_state.todo_do_loop = true;
 394 }
 395
 396 static inline int vkd3d_test_loop_todo(void)
 397 {
 398     bool do_loop = vkd3d_test_state.todo_do_loop;
 399     vkd3d_test_state.todo_do_loop = false;
 400     return do_loop;
 401 }
 402
 403 static inline void vkd3d_test_end_todo(void)
 404 {
 405     vkd3d_test_state.todo_level >>= 1;
 406 }
 407
 408 static inline void vkd3d_test_start_bug(bool is_bug)
 409 {
 410     vkd3d_test_state.bug_level = (vkd3d_test_state.bug_level << 1) | is_bug;
 411     vkd3d_test_state.bug_do_loop = true;
 412 }
 413
 414 static inline int vkd3d_test_loop_bug(void)
 415 {
 416     bool do_loop = vkd3d_test_state.bug_do_loop;
 417     vkd3d_test_state.bug_do_loop = false;
 418     return do_loop;
 419 }
 420
 421 static inline void vkd3d_test_end_bug(void)
 422 {
 423     vkd3d_test_state.bug_level >>= 1;
 424 }
 425
 426 static inline void vkd3d_test_push_context(const char *fmt, ...)
 427 {
 428     va_list args;
 429
 430     if (vkd3d_test_state.context_count < ARRAY_SIZE(vkd3d_test_state.context))
 431     {
 432         va_start(args, fmt);
 433         vsnprintf(vkd3d_test_state.context[vkd3d_test_state.context_count],
 434                 sizeof(*vkd3d_test_state.context), fmt, args);
 435         va_end(args);
 436         vkd3d_test_state.context[vkd3d_test_state.context_count][sizeof(vkd3d_test_state.context[0]) - 1] = '\0';
 437     }
 438     ++vkd3d_test_state.context_count;
 439 }
 440
 441 static inline void vkd3d_test_pop_context(void)
 442 {
 443     if (vkd3d_test_state.context_count)
 444         --vkd3d_test_state.context_count;
 445 }
 446
 447 #define run_test(test_pfn) \
 448         vkd3d_run_test(#test_pfn, test_pfn)
 449
 450 #endif  /* __VKD3D_TEST_H */