modules/rostests/winetests/setupapi/setupcab.c

   1 /*
   2  * Unit tests for SetupIterateCabinet
   3  *
   4  * Copyright 2007 Hans Leidekker
   5  * Copyright 2010 Andrew Nguyen
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "setupapi.h"
  30 #include "wine/test.h"
  31
  32 static const BYTE comp_cab_zip_multi[] = {
  33     0x4d, 0x53, 0x43, 0x46, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  34     0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00,
  35     0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00,
  36     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x38, 0xf0, 0x48, 0x20, 0x00, 0x74, 0x72, 0x69, 0x73,
  37     0x74, 0x72, 0x61, 0x6d, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd1,
  38     0x38, 0xf0, 0x48, 0x20, 0x00, 0x77, 0x69, 0x6e, 0x65, 0x00, 0x08, 0x00, 0x00, 0x00, 0x18, 0x00,
  39     0x00, 0x00, 0x00, 0x00, 0xd1, 0x38, 0xf0, 0x48, 0x20, 0x00, 0x73, 0x68, 0x61, 0x6e, 0x64, 0x79,
  40     0x00, 0x67, 0x2c, 0x03, 0x85, 0x23, 0x00, 0x20, 0x00, 0x43, 0x4b, 0xcb, 0x49, 0x2c, 0x2d, 0x4a,
  41     0xcd, 0x4b, 0x4e, 0xe5, 0xe5, 0x2a, 0xcd, 0x4b, 0xce, 0xcf, 0x2d, 0x28, 0x4a, 0x2d, 0x2e, 0x4e,
  42     0x4d, 0xe1, 0xe5, 0x2a, 0x2e, 0x49, 0x2d, 0xca, 0x03, 0x8a, 0x02, 0x00
  43 };
  44
  45 static const WCHAR docW[] = {'d','o','c',0};
  46
  47 static void create_source_fileA(LPSTR filename, const BYTE *data, DWORD size)
  48 {
  49     HANDLE handle;
  50     DWORD written;
  51
  52     handle = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
  53                          FILE_ATTRIBUTE_NORMAL, NULL);
  54     WriteFile(handle, data, size, &written, NULL);
  55     CloseHandle(handle);
  56 }
  57
  58 static void create_source_fileW(LPWSTR filename, const BYTE *data, DWORD size)
  59 {
  60     HANDLE handle;
  61     DWORD written;
  62
  63     handle = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
  64                          FILE_ATTRIBUTE_NORMAL, NULL);
  65     WriteFile(handle, data, size, &written, NULL);
  66     CloseHandle(handle);
  67 }
  68
  69 static UINT CALLBACK dummy_callbackA(PVOID Context, UINT Notification,
  70                                      UINT_PTR Param1, UINT_PTR Param2)
  71 {
  72     ok(0, "Received unexpected notification (%p, %u, %lu, %lu)\n", Context,
  73        Notification, Param1, Param2);
  74     return 0;
  75 }
  76
  77 static UINT CALLBACK dummy_callbackW(PVOID Context, UINT Notification,
  78                                      UINT_PTR Param1, UINT_PTR Param2)
  79 {
  80     ok(0, "Received unexpected notification (%p, %u, %lu, %lu)\n", Context,
  81        Notification, Param1, Param2);
  82     return 0;
  83 }
  84
  85 static void test_invalid_parametersA(void)
  86 {
  87     BOOL ret;
  88     char source[MAX_PATH], temp[MAX_PATH];
  89     int i;
  90
  91     const struct
  92     {
  93         PCSTR CabinetFile;
  94         PSP_FILE_CALLBACK_A MsgHandler;
  95         DWORD expected_lasterror;
  96         int todo_lasterror;
  97     } invalid_parameters[] =
  98     {
  99         {NULL,                  NULL,            ERROR_INVALID_PARAMETER},
 100         {NULL,                  dummy_callbackA, ERROR_INVALID_PARAMETER},
 101         {"c:\\nonexistent.cab", NULL,            ERROR_FILE_NOT_FOUND},
 102         {"c:\\nonexistent.cab", dummy_callbackA, ERROR_FILE_NOT_FOUND},
 103         {source,                NULL,            ERROR_INVALID_DATA, 1},
 104         {source,                dummy_callbackA, ERROR_INVALID_DATA, 1},
 105     };
 106
 107     GetTempPathA(sizeof(temp), temp);
 108     GetTempFileNameA(temp, "doc", 0, source);
 109
 110     create_source_fileA(source, NULL, 0);
 111
 112     for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
 113     {
 114         SetLastError(0xdeadbeef);
 115         ret = SetupIterateCabinetA(invalid_parameters[i].CabinetFile, 0,
 116                                    invalid_parameters[i].MsgHandler, NULL);
 117         ok(!ret, "[%d] Expected SetupIterateCabinetA to return 0, got %d\n", i, ret);
 118         todo_wine_if (invalid_parameters[i].todo_lasterror)
 119             ok(GetLastError() == invalid_parameters[i].expected_lasterror,
 120                "[%d] Expected GetLastError() to return %u, got %u\n",
 121                i, invalid_parameters[i].expected_lasterror, GetLastError());
 122     }
 123
 124     SetLastError(0xdeadbeef);
 125     ret = SetupIterateCabinetA("", 0, NULL, NULL);
 126     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
 127     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
 128        GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x/NT4/Win2k */
 129        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
 130        GetLastError());
 131
 132     SetLastError(0xdeadbeef);
 133     ret = SetupIterateCabinetA("", 0, dummy_callbackA, NULL);
 134     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
 135     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
 136        GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x/NT4/Win2k */
 137        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
 138        GetLastError());
 139
 140     DeleteFileA(source);
 141 }
 142
 143 static void test_invalid_parametersW(void)
 144 {
 145     static const WCHAR nonexistentW[] = {'c',':','\\','n','o','n','e','x','i','s','t','e','n','t','.','c','a','b',0};
 146     static const WCHAR emptyW[] = {0};
 147
 148     BOOL ret;
 149     WCHAR source[MAX_PATH], temp[MAX_PATH];
 150     int i;
 151
 152     const struct
 153     {
 154         PCWSTR CabinetFile;
 155         PSP_FILE_CALLBACK_W MsgHandler;
 156         DWORD expected_lasterror;
 157         int todo_lasterror;
 158     } invalid_parameters[] =
 159     {
 160         {nonexistentW, NULL,            ERROR_FILE_NOT_FOUND},
 161         {nonexistentW, dummy_callbackW, ERROR_FILE_NOT_FOUND},
 162         {source,       NULL,            ERROR_INVALID_DATA, 1},
 163         {source,       dummy_callbackW, ERROR_INVALID_DATA, 1},
 164     };
 165
 166     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
 167     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 168     {
 169         win_skip("SetupIterateCabinetW is not available\n");
 170         return;
 171     }
 172
 173     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
 174     GetTempFileNameW(temp, docW, 0, source);
 175
 176     create_source_fileW(source, NULL, 0);
 177
 178     for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
 179     {
 180         SetLastError(0xdeadbeef);
 181         ret = SetupIterateCabinetW(invalid_parameters[i].CabinetFile, 0,
 182                                    invalid_parameters[i].MsgHandler, NULL);
 183         ok(!ret, "[%d] Expected SetupIterateCabinetW to return 0, got %d\n", i, ret);
 184         todo_wine_if (invalid_parameters[i].todo_lasterror)
 185             ok(GetLastError() == invalid_parameters[i].expected_lasterror,
 186                "[%d] Expected GetLastError() to return %u, got %u\n",
 187                i, invalid_parameters[i].expected_lasterror, GetLastError());
 188     }
 189
 190     SetLastError(0xdeadbeef);
 191     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
 192     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
 193     ok(GetLastError() == ERROR_INVALID_PARAMETER ||
 194        GetLastError() == ERROR_NOT_ENOUGH_MEMORY, /* Vista/Win2k8 */
 195        "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
 196        GetLastError());
 197
 198     SetLastError(0xdeadbeef);
 199     ret = SetupIterateCabinetW(NULL, 0, dummy_callbackW, NULL);
 200     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
 201     ok(GetLastError() == ERROR_INVALID_PARAMETER ||
 202        GetLastError() == ERROR_NOT_ENOUGH_MEMORY, /* Vista/Win2k8 */
 203        "Expected GetLastError() to return ERROR_INVALID_PARAMETER, got %u\n",
 204        GetLastError());
 205
 206     SetLastError(0xdeadbeef);
 207     ret = SetupIterateCabinetW(emptyW, 0, NULL, NULL);
 208     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
 209     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
 210        GetLastError() == ERROR_FILE_NOT_FOUND, /* NT4/Win2k */
 211        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
 212        GetLastError());
 213
 214     SetLastError(0xdeadbeef);
 215     ret = SetupIterateCabinetW(emptyW, 0, dummy_callbackW, NULL);
 216     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
 217     ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY ||
 218        GetLastError() == ERROR_FILE_NOT_FOUND, /* NT4/Win2k */
 219        "Expected GetLastError() to return ERROR_NOT_ENOUGH_MEMORY, got %u\n",
 220        GetLastError());
 221
 222     DeleteFileW(source);
 223 }
 224
 225 static UINT CALLBACK crash_callbackA(PVOID Context, UINT Notification,
 226                                      UINT_PTR Param1, UINT_PTR Param2)
 227 {
 228     *(volatile char*)0 = 2;
 229     return 0;
 230 }
 231
 232 static UINT CALLBACK crash_callbackW(PVOID Context, UINT Notification,
 233                                      UINT_PTR Param1, UINT_PTR Param2)
 234 {
 235     *(volatile char*)0 = 2;
 236     return 0;
 237 }
 238
 239 static void test_invalid_callbackA(void)
 240 {
 241     BOOL ret;
 242     char source[MAX_PATH], temp[MAX_PATH];
 243
 244     GetTempPathA(sizeof(temp), temp);
 245     GetTempFileNameA(temp, "doc", 0, source);
 246
 247     create_source_fileA(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
 248
 249     SetLastError(0xdeadbeef);
 250     ret = SetupIterateCabinetA(source, 0, NULL, NULL);
 251     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
 252     ok(GetLastError() == ERROR_INVALID_DATA,
 253        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
 254        GetLastError());
 255
 256     SetLastError(0xdeadbeef);
 257     ret = SetupIterateCabinetA(source, 0, crash_callbackA, NULL);
 258     ok(!ret, "Expected SetupIterateCabinetA to return 0, got %d\n", ret);
 259     ok(GetLastError() == ERROR_INVALID_DATA,
 260        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
 261        GetLastError());
 262
 263     DeleteFileA(source);
 264 }
 265
 266 static void test_invalid_callbackW(void)
 267 {
 268     BOOL ret;
 269     WCHAR source[MAX_PATH], temp[MAX_PATH];
 270
 271     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
 272     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 273     {
 274         win_skip("SetupIterateCabinetW is not available\n");
 275         return;
 276     }
 277
 278     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
 279     GetTempFileNameW(temp, docW, 0, source);
 280
 281     create_source_fileW(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
 282
 283     SetLastError(0xdeadbeef);
 284     ret = SetupIterateCabinetW(source, 0, NULL, NULL);
 285     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
 286     ok(GetLastError() == ERROR_INVALID_DATA,
 287        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
 288        GetLastError());
 289
 290     SetLastError(0xdeadbeef);
 291     ret = SetupIterateCabinetW(source, 0, crash_callbackW, NULL);
 292     ok(!ret, "Expected SetupIterateCabinetW to return 0, got %d\n", ret);
 293     ok(GetLastError() == ERROR_INVALID_DATA,
 294        "Expected GetLastError() to return ERROR_INVALID_DATA, got %u\n",
 295        GetLastError());
 296
 297     DeleteFileW(source);
 298 }
 299
 300 static const char *expected_files[] = {"tristram", "wine", "shandy"};
 301
 302 struct contextA
 303 {
 304     int count;
 305     const char *cabinet;
 306     const char *target;
 307 };
 308
 309 static UINT CALLBACK simple_callbackA(PVOID Context, UINT Notification,
 310                                       UINT_PTR Param1, UINT_PTR Param2)
 311 {
 312     static int index;
 313     struct contextA *ctx = Context;
 314
 315     switch (Notification)
 316     {
 317     case SPFILENOTIFY_CABINETINFO:
 318     {
 319         CABINET_INFO_A *info = (CABINET_INFO_A *)Param1;
 320
 321         ok(!strcmp(info->CabinetFile, ""),
 322            "Expected empty CabinetFile, got \"%s\"\n", info->CabinetFile);
 323
 324         index = 0;
 325         return NO_ERROR;
 326     }
 327     case SPFILENOTIFY_FILEINCABINET:
 328     {
 329         FILE_IN_CABINET_INFO_A *info = (FILE_IN_CABINET_INFO_A *)Param1;
 330         const char *cabinet_file = (const char *)Param2;
 331
 332         ctx->count++;
 333
 334         if (index < sizeof(expected_files)/sizeof(char *))
 335         {
 336             ok(!strcmp(expected_files[index], info->NameInCabinet),
 337                "[%d] Expected file \"%s\", got \"%s\"\n",
 338                index, expected_files[index], info->NameInCabinet);
 339             ok(!strcmp(ctx->cabinet, cabinet_file),
 340                "[%d] Expected cabinet \"%s\", got \"%s\"\n",
 341                index, ctx->cabinet, cabinet_file);
 342
 343             strcpy(info->FullTargetName, ctx->target);
 344             return FILEOP_DOIT;
 345         }
 346         else
 347         {
 348             ok(0, "Unexpectedly enumerated more than number of files in cabinet, index = %d\n", index);
 349             return FILEOP_ABORT;
 350         }
 351     }
 352     case SPFILENOTIFY_FILEEXTRACTED:
 353     {
 354         FILEPATHS_A *info = (FILEPATHS_A *)Param1;
 355
 356         ok(!strcmp(ctx->cabinet, info->Source),
 357            "[%d] Expected cabinet \"%s\", got \"%s\"\n",
 358            index, ctx->cabinet, info->Source);
 359         ok(!strcmp(ctx->target, info->Target),
 360            "[%d] Expected target \"%s\", got \"%s\"\n",
 361            index, ctx->target, info->Target);
 362         ok(info->Win32Error == 0,
 363            "[%d] Expected Win32Error 0, got %u\n",
 364            index, info->Win32Error);
 365
 366         index++;
 367         return NO_ERROR;
 368     }
 369     default:
 370         return NO_ERROR;
 371     }
 372 }
 373
 374 static void test_simple_enumerationA(void)
 375 {
 376     BOOL ret;
 377     char source[MAX_PATH], temp[MAX_PATH];
 378     char target[MAX_PATH];
 379     struct contextA ctx;
 380
 381     GetTempPathA(sizeof(temp), temp);
 382     GetTempFileNameA(temp, "doc", 0, source);
 383     GetTempFileNameA(temp, "doc", 0, target);
 384
 385     create_source_fileA(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
 386
 387     ctx.count = 0;
 388     ctx.cabinet = source;
 389     ctx.target = target;
 390     ret = SetupIterateCabinetA(source, 0, simple_callbackA, &ctx);
 391     ok(ret == 1, "Expected SetupIterateCabinetA to return 1, got %d\n", ret);
 392     ok(ctx.count == sizeof(expected_files)/sizeof(char *),
 393        "Unexpectedly enumerated %d files\n", ctx.count);
 394
 395     DeleteFileA(source);
 396     DeleteFileA(target);
 397 }
 398
 399 static const WCHAR tristramW[] = {'t','r','i','s','t','r','a','m',0};
 400 static const WCHAR wineW[] = {'w','i','n','e',0};
 401 static const WCHAR shandyW[] = {'s','h','a','n','d','y',0};
 402 static const WCHAR *expected_filesW[] = {tristramW, wineW, shandyW};
 403
 404 struct contextW
 405 {
 406     int count;
 407     const WCHAR *cabinet;
 408     const WCHAR *target;
 409 };
 410
 411 static UINT CALLBACK simple_callbackW(PVOID Context, UINT Notification,
 412                                       UINT_PTR Param1, UINT_PTR Param2)
 413 {
 414     static const WCHAR emptyW[] = {0};
 415     static int index;
 416     struct contextW *ctx = Context;
 417
 418     switch (Notification)
 419     {
 420     case SPFILENOTIFY_CABINETINFO:
 421     {
 422         CABINET_INFO_W *info = (CABINET_INFO_W *)Param1;
 423
 424         ok(!lstrcmpW(info->CabinetFile, emptyW),
 425            "Expected empty CabinetFile, got %s\n", wine_dbgstr_w(info->CabinetFile));
 426
 427         index = 0;
 428         return NO_ERROR;
 429     }
 430     case SPFILENOTIFY_FILEINCABINET:
 431     {
 432         FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)Param1;
 433         const WCHAR *cabinet_file = (const WCHAR *)Param2;
 434
 435         ctx->count++;
 436
 437         if (index < sizeof(expected_filesW)/sizeof(WCHAR *))
 438         {
 439             ok(!lstrcmpW(expected_filesW[index], info->NameInCabinet),
 440                "[%d] Expected file %s, got %s\n",
 441                index, wine_dbgstr_w(expected_filesW[index]), wine_dbgstr_w(info->NameInCabinet));
 442             ok(!lstrcmpW(ctx->cabinet, cabinet_file),
 443                "[%d] Expected cabinet %s, got %s\n",
 444                index, wine_dbgstr_w(ctx->cabinet), wine_dbgstr_w(cabinet_file));
 445
 446             lstrcpyW(info->FullTargetName, ctx->target);
 447             return FILEOP_DOIT;
 448         }
 449         else
 450         {
 451             ok(0, "Unexpectedly enumerated more than number of files in cabinet, index = %d\n", index);
 452             return FILEOP_ABORT;
 453         }
 454     }
 455     case SPFILENOTIFY_FILEEXTRACTED:
 456     {
 457         FILEPATHS_W *info = (FILEPATHS_W *)Param1;
 458
 459         ok(!lstrcmpW(ctx->cabinet, info->Source),
 460            "[%d] Expected cabinet %s, got %s\n",
 461            index, wine_dbgstr_w(ctx->cabinet), wine_dbgstr_w(info->Source));
 462         ok(!lstrcmpW(ctx->target, info->Target),
 463            "[%d] Expected target %s, got %s\n",
 464            index, wine_dbgstr_w(ctx->target), wine_dbgstr_w(info->Target));
 465         ok(info->Win32Error == 0,
 466            "[%d] Expected Win32Error 0, got %u\n",
 467            index, info->Win32Error);
 468
 469         index++;
 470         return NO_ERROR;
 471     }
 472     default:
 473         return NO_ERROR;
 474     }
 475 }
 476
 477 static void test_simple_enumerationW(void)
 478 {
 479     BOOL ret;
 480     WCHAR source[MAX_PATH], temp[MAX_PATH];
 481     WCHAR target[MAX_PATH];
 482     struct contextW ctx;
 483
 484     ret = SetupIterateCabinetW(NULL, 0, NULL, NULL);
 485     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 486     {
 487         win_skip("SetupIterateCabinetW is not available\n");
 488         return;
 489     }
 490
 491     GetTempPathW(sizeof(temp)/sizeof(WCHAR), temp);
 492     GetTempFileNameW(temp, docW, 0, source);
 493     GetTempFileNameW(temp, docW, 0, target);
 494
 495     create_source_fileW(source, comp_cab_zip_multi, sizeof(comp_cab_zip_multi));
 496
 497     ctx.count = 0;
 498     ctx.cabinet = source;
 499     ctx.target = target;
 500     ret = SetupIterateCabinetW(source, 0, simple_callbackW, &ctx);
 501     ok(ret == 1, "Expected SetupIterateCabinetW to return 1, got %d\n", ret);
 502     ok(ctx.count == sizeof(expected_files)/sizeof(WCHAR *),
 503        "Unexpectedly enumerated %d files\n", ctx.count);
 504
 505     DeleteFileW(source);
 506     DeleteFileW(target);
 507 }
 508
 509 START_TEST(setupcab)
 510 {
 511     test_invalid_parametersA();
 512     test_invalid_parametersW();
 513
 514     /* Tests crash on NT4/Win9x/Win2k and Wine. */
 515     if (0)
 516     {
 517         test_invalid_callbackA();
 518         test_invalid_callbackW();
 519     }
 520
 521     test_simple_enumerationA();
 522     test_simple_enumerationW();
 523 }