rostests/winetests/kernel32/version.c

   1 /*
   2  * Unit test suite for version functions
   3  *
   4  * Copyright 2006 Robert Shearman
   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 /* Needed for PRODUCT_* defines and GetProductInfo() */
  22 #define _WIN32_WINNT 0x0600
  23
  24 #include "wine/test.h"
  25 #include "winbase.h"
  26 #include "wine/winternl.h"
  27
  28 static BOOL (WINAPI * pGetProductInfo)(DWORD, DWORD, DWORD, DWORD, DWORD *);
  29 static BOOL (WINAPI * pVerifyVersionInfoA)(LPOSVERSIONINFOEXA, DWORD, DWORDLONG);
  30 static ULONGLONG (WINAPI * pVerSetConditionMask)(ULONGLONG, DWORD, BYTE);
  31 static NTSTATUS (WINAPI * pRtlGetVersion)(RTL_OSVERSIONINFOEXW *);
  32
  33 #define GET_PROC(func)                                     \
  34     p##func = (void *)GetProcAddress(hmod, #func);
  35
  36 static void init_function_pointers(void)
  37 {
  38     HMODULE hmod;
  39
  40     hmod = GetModuleHandleA("kernel32.dll");
  41
  42     GET_PROC(GetProductInfo);
  43     GET_PROC(VerifyVersionInfoA);
  44     GET_PROC(VerSetConditionMask);
  45
  46     hmod = GetModuleHandleA("ntdll.dll");
  47
  48     GET_PROC(RtlGetVersion);
  49 }
  50
  51 static void test_GetProductInfo(void)
  52 {
  53     DWORD product;
  54     DWORD res;
  55     DWORD table[] = {9,8,7,6,
  56                      7,0,0,0,
  57                      6,2,0,0,
  58                      6,1,2,0,
  59                      6,1,1,0,
  60                      6,1,0,2,
  61                      6,1,0,0,
  62                      6,0,3,0,
  63                      6,0,2,0,
  64                      6,0,1,5,
  65                      6,0,1,0,
  66                      6,0,0,0,
  67                      5,3,0,0,
  68                      5,2,0,0,
  69                      5,1,0,0,
  70                      5,0,0,0,
  71                      0};
  72
  73     DWORD *entry = table;
  74
  75     if (!pGetProductInfo)
  76     {
  77         /* Not present before Vista */
  78         win_skip("GetProductInfo() not available\n");
  79         return;
  80     }
  81
  82     while (*entry)
  83     {
  84         /* SetLastError() / GetLastError(): value is untouched */
  85         product = 0xdeadbeef;
  86         SetLastError(0xdeadbeef);
  87         res = pGetProductInfo(entry[0], entry[1], entry[2], entry[3], &product);
  88
  89         if (entry[0] >= 6)
  90             ok(res && (product > PRODUCT_UNDEFINED) && (product <= PRODUCT_PROFESSIONAL_WMC),
  91                "got %d and 0x%x (expected TRUE and a valid PRODUCT_* value)\n", res, product);
  92         else
  93             ok(!res && !product && (GetLastError() == 0xdeadbeef),
  94                "got %d and 0x%x with 0x%x (expected FALSE and PRODUCT_UNDEFINED with LastError untouched)\n",
  95                res, product, GetLastError());
  96
  97         entry+= 4;
  98     }
  99
 100     /* NULL pointer is not a problem */
 101     SetLastError(0xdeadbeef);
 102     res = pGetProductInfo(6, 1, 0, 0, NULL);
 103     ok( (!res) && (GetLastError() == 0xdeadbeef),
 104         "got %d with 0x%x (expected FALSE with LastError untouched\n", res, GetLastError());
 105 }
 106
 107 static void test_GetVersionEx(void)
 108 {
 109     OSVERSIONINFOA infoA;
 110     OSVERSIONINFOEXA infoExA;
 111     BOOL ret;
 112
 113     if (0)
 114     {
 115         /* Silently crashes on XP */
 116         GetVersionExA(NULL);
 117     }
 118
 119     SetLastError(0xdeadbeef);
 120     memset(&infoA,0,sizeof infoA);
 121     ret = GetVersionExA(&infoA);
 122     ok(!ret, "Expected GetVersionExA to fail\n");
 123     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER ||
 124         GetLastError() == 0xdeadbeef /* Win9x */,
 125         "Expected ERROR_INSUFFICIENT_BUFFER or 0xdeadbeef (Win9x), got %d\n",
 126         GetLastError());
 127
 128     SetLastError(0xdeadbeef);
 129     infoA.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA) / 2;
 130     ret = GetVersionExA(&infoA);
 131     ok(!ret, "Expected GetVersionExA to fail\n");
 132     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER ||
 133         GetLastError() == 0xdeadbeef /* Win9x */,
 134         "Expected ERROR_INSUFFICIENT_BUFFER or 0xdeadbeef (Win9x), got %d\n",
 135         GetLastError());
 136
 137     SetLastError(0xdeadbeef);
 138     infoA.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA) * 2;
 139     ret = GetVersionExA(&infoA);
 140     ok(!ret, "Expected GetVersionExA to fail\n");
 141     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER ||
 142         GetLastError() == 0xdeadbeef /* Win9x */,
 143         "Expected ERROR_INSUFFICIENT_BUFFER or 0xdeadbeef (Win9x), got %d\n",
 144         GetLastError());
 145
 146     SetLastError(0xdeadbeef);
 147     infoA.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
 148     ret = GetVersionExA(&infoA);
 149     ok(ret, "Expected GetVersionExA to succeed\n");
 150     ok(GetLastError() == 0xdeadbeef,
 151         "Expected 0xdeadbeef, got %d\n", GetLastError());
 152
 153     SetLastError(0xdeadbeef);
 154     infoExA.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 155     ret = GetVersionExA((OSVERSIONINFOA *)&infoExA);
 156     ok(ret ||
 157        broken(ret == 0), /* win95 */
 158        "Expected GetVersionExA to succeed\n");
 159 }
 160
 161 static void test_VerifyVersionInfo(void)
 162 {
 163     OSVERSIONINFOEXA info;
 164     BOOL ret;
 165     DWORD servicepack, error;
 166
 167     if(!pVerifyVersionInfoA || !pVerSetConditionMask)
 168     {
 169         win_skip("Needed functions not available\n");
 170         return;
 171     }
 172
 173     /* Before we start doing some tests we should check what the version of
 174      * the ServicePack is. Tests on a box with no ServicePack will fail otherwise.
 175      */
 176     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 177     GetVersionExA((OSVERSIONINFOA *)&info);
 178     servicepack = info.wServicePackMajor;
 179
 180     /* Win8.1+ returns Win8 version in GetVersionEx when there's no app manifest targeting 8.1 */
 181     if (info.dwMajorVersion == 6 && info.dwMinorVersion == 2)
 182     {
 183         RTL_OSVERSIONINFOEXW rtlinfo;
 184         rtlinfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
 185         ok(SUCCEEDED(pRtlGetVersion(&rtlinfo)), "RtlGetVersion failed\n");
 186
 187         if (rtlinfo.dwMajorVersion != 6 || rtlinfo.dwMinorVersion != 2)
 188         {
 189             win_skip("GetVersionEx and VerifyVersionInfo are faking values\n");
 190             return;
 191         }
 192     }
 193
 194     memset(&info, 0, sizeof(info));
 195
 196     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION,
 197         pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL));
 198     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 199
 200     SetLastError(0xdeadbeef);
 201     ret = pVerifyVersionInfoA(&info, VER_BUILDNUMBER | VER_MAJORVERSION |
 202         VER_MINORVERSION/* | VER_PLATFORMID | VER_SERVICEPACKMAJOR |
 203         VER_SERVICEPACKMINOR | VER_SUITENAME | VER_PRODUCT_TYPE */,
 204         pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL));
 205     error = GetLastError();
 206     ok(!ret, "VerifyVersionInfoA succeeded\n");
 207     ok(error == ERROR_OLD_WIN_VERSION,
 208        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 209
 210     /* tests special handling of VER_SUITENAME */
 211
 212     ret = pVerifyVersionInfoA(&info, VER_SUITENAME,
 213         pVerSetConditionMask(0, VER_SUITENAME, VER_AND));
 214     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 215
 216     ret = pVerifyVersionInfoA(&info, VER_SUITENAME,
 217         pVerSetConditionMask(0, VER_SUITENAME, VER_OR));
 218     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 219
 220     /* test handling of version numbers */
 221
 222     /* v3.10 is always less than v4.x even
 223      * if the minor version is tested */
 224     info.dwMajorVersion = 3;
 225     info.dwMinorVersion = 10;
 226     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 227         pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL),
 228             VER_MAJORVERSION, VER_GREATER_EQUAL));
 229     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 230
 231     info.dwMinorVersion = 0;
 232     info.wServicePackMajor = 10;
 233     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 234         pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL),
 235             VER_MAJORVERSION, VER_GREATER_EQUAL));
 236     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 237
 238     info.wServicePackMajor = 0;
 239     info.wServicePackMinor = 10;
 240     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 241         pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL),
 242             VER_MAJORVERSION, VER_GREATER_EQUAL));
 243     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 244
 245     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 246     GetVersionExA((OSVERSIONINFOA *)&info);
 247     info.wServicePackMinor++;
 248     SetLastError(0xdeadbeef);
 249     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 250         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 251     error = GetLastError();
 252     ok(!ret, "VerifyVersionInfoA succeeded\n");
 253     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some wink2 */,
 254        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 255
 256     if (servicepack == 0)
 257     {
 258         skip("There is no ServicePack on this system\n");
 259     }
 260     else
 261     {
 262         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 263         GetVersionExA((OSVERSIONINFOA *)&info);
 264         info.wServicePackMajor--;
 265         ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 266             pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER));
 267         ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 268
 269         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 270         GetVersionExA((OSVERSIONINFOA *)&info);
 271         info.wServicePackMajor--;
 272         ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 273             pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 274         ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 275     }
 276
 277     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 278     GetVersionExA((OSVERSIONINFOA *)&info);
 279     info.wServicePackMajor++;
 280     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 281         pVerSetConditionMask(0, VER_MINORVERSION, VER_LESS));
 282     ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 283
 284     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 285     GetVersionExA((OSVERSIONINFOA *)&info);
 286     info.wServicePackMajor++;
 287     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 288         pVerSetConditionMask(0, VER_MINORVERSION, VER_LESS_EQUAL));
 289     ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 290
 291     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 292     GetVersionExA((OSVERSIONINFOA *)&info);
 293     info.wServicePackMajor--;
 294     SetLastError(0xdeadbeef);
 295     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 296         pVerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL));
 297     error = GetLastError();
 298     ok(!ret, "VerifyVersionInfoA succeeded\n");
 299     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 300        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 301
 302     /* test the failure hierarchy for the four version fields */
 303
 304     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 305     GetVersionExA((OSVERSIONINFOA *)&info);
 306     info.wServicePackMajor++;
 307     SetLastError(0xdeadbeef);
 308     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 309         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 310     error = GetLastError();
 311     ok(!ret, "VerifyVersionInfoA succeeded\n");
 312     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 313        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 314
 315     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 316     GetVersionExA((OSVERSIONINFOA *)&info);
 317     info.dwMinorVersion++;
 318     SetLastError(0xdeadbeef);
 319     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 320         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 321     error = GetLastError();
 322     ok(!ret, "VerifyVersionInfoA succeeded\n");
 323     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 324        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 325
 326     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 327     GetVersionExA((OSVERSIONINFOA *)&info);
 328     info.dwMajorVersion++;
 329     SetLastError(0xdeadbeef);
 330     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 331         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 332     error = GetLastError();
 333     ok(!ret, "VerifyVersionInfoA succeeded\n");
 334     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 335        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 336
 337     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 338         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 339     ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 340
 341     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 342     GetVersionExA((OSVERSIONINFOA *)&info);
 343     info.dwBuildNumber++;
 344     SetLastError(0xdeadbeef);
 345     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 346         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 347     error = GetLastError();
 348     ok(!ret, "VerifyVersionInfoA succeeded\n");
 349     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 350        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 351
 352     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 353         pVerSetConditionMask(0, VER_MINORVERSION, VER_GREATER_EQUAL));
 354     ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 355
 356     /* systematically test behaviour of condition mask (tests sorted by condition mask value) */
 357
 358     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 359     GetVersionExA((OSVERSIONINFOA *)&info);
 360     info.dwMinorVersion++;
 361     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 362         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_MINORVERSION, VER_LESS));
 363     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 364
 365     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 366     GetVersionExA((OSVERSIONINFOA *)&info);
 367     info.dwMinorVersion++;
 368     SetLastError(0xdeadbeef);
 369     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 370         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_MINORVERSION, VER_LESS));
 371     error = GetLastError();
 372     ok(!ret, "VerifyVersionInfoA succeeded\n");
 373     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 374        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 375
 376     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 377     GetVersionExA((OSVERSIONINFOA *)&info);
 378     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 379         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_MINORVERSION, VER_LESS));
 380     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 381
 382     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 383     GetVersionExA((OSVERSIONINFOA *)&info);
 384     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 385         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_MINORVERSION, VER_AND));
 386     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 387
 388     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 389     GetVersionExA((OSVERSIONINFOA *)&info);
 390     info.dwMinorVersion++;
 391     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 392         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_LESS_EQUAL), VER_MINORVERSION, VER_LESS));
 393     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 394
 395     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 396     GetVersionExA((OSVERSIONINFOA *)&info);
 397     info.dwMinorVersion++;
 398     SetLastError(0xdeadbeef);
 399     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 400         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_AND), VER_MINORVERSION, VER_LESS));
 401     error = GetLastError();
 402     ok(!ret, "VerifyVersionInfoA succeeded\n");
 403     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 404        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 405
 406     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 407     GetVersionExA((OSVERSIONINFOA *)&info);
 408     info.dwMinorVersion++;
 409     SetLastError(0xdeadbeef);
 410     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 411         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_OR), VER_MINORVERSION, VER_LESS));
 412     error = GetLastError();
 413     ok(!ret, "VerifyVersionInfoA succeeded\n");
 414     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 415        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 416
 417     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 418     GetVersionExA((OSVERSIONINFOA *)&info);
 419     info.wServicePackMinor++;
 420     SetLastError(0xdeadbeef);
 421     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 422         pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 423     error = GetLastError();
 424     ok(!ret, "VerifyVersionInfoA succeeded\n");
 425     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 426        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 427
 428     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 429     GetVersionExA((OSVERSIONINFOA *)&info);
 430     info.wServicePackMinor++;
 431     SetLastError(0xdeadbeef);
 432     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 433         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 434     error = GetLastError();
 435     ok(!ret, "VerifyVersionInfoA succeeded\n");
 436     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 437        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 438
 439     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 440     GetVersionExA((OSVERSIONINFOA *)&info);
 441     info.wServicePackMajor++;
 442     SetLastError(0xdeadbeef);
 443     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 444         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_EQUAL));
 445     error = GetLastError();
 446     ok(!ret, "VerifyVersionInfoA succeeded\n");
 447     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 448        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 449
 450     if (servicepack)
 451     {
 452         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 453         GetVersionExA((OSVERSIONINFOA *)&info);
 454         info.dwMajorVersion++;
 455         info.wServicePackMajor--;
 456         ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 457             pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_LESS), VER_SERVICEPACKMAJOR, VER_EQUAL));
 458         ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 459     }
 460
 461     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 462     GetVersionExA((OSVERSIONINFOA *)&info);
 463     info.wServicePackMinor++;
 464     ret = pVerifyVersionInfoA(&info, VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 465         pVerSetConditionMask(pVerSetConditionMask(0, VER_SERVICEPACKMAJOR, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 466     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 467
 468     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 469     GetVersionExA((OSVERSIONINFOA *)&info);
 470     info.wServicePackMinor++;
 471     SetLastError(0xdeadbeef);
 472     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 473         pVerSetConditionMask(pVerSetConditionMask(0, VER_SERVICEPACKMAJOR, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 474     error = GetLastError();
 475     ok(!ret, "VerifyVersionInfoA succeeded\n");
 476     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 477        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 478
 479     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 480     GetVersionExA((OSVERSIONINFOA *)&info);
 481     info.wServicePackMinor++;
 482     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 483         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL),
 484         VER_SERVICEPACKMAJOR, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 485     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 486
 487     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 488     GetVersionExA((OSVERSIONINFOA *)&info);
 489     info.wServicePackMinor++;
 490     SetLastError(0xdeadbeef);
 491     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 492         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL),
 493         VER_SERVICEPACKMAJOR, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 494     error = GetLastError();
 495     ok(!ret, "VerifyVersionInfoA succeeded\n");
 496     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 497        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 498
 499     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 500     GetVersionExA((OSVERSIONINFOA *)&info);
 501     info.wServicePackMinor++;
 502     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 503         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL),
 504         VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 505     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 506
 507     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 508     GetVersionExA((OSVERSIONINFOA *)&info);
 509     info.wServicePackMinor++;
 510     SetLastError(0xdeadbeef);
 511     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 512         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL),
 513         VER_MINORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_EQUAL), VER_SERVICEPACKMINOR, VER_LESS));
 514     error = GetLastError();
 515     ok(!ret, "VerifyVersionInfoA succeeded\n");
 516     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 517        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 518
 519     if (servicepack)
 520     {
 521         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 522         GetVersionExA((OSVERSIONINFOA *)&info);
 523         info.wServicePackMajor--;
 524         SetLastError(0xdeadbeef);
 525         ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 526             pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_GREATER));
 527         error = GetLastError();
 528         ok(!ret, "VerifyVersionInfoA succeeded\n");
 529         ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 530            "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 531
 532         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 533         GetVersionExA((OSVERSIONINFOA *)&info);
 534         info.wServicePackMajor--;
 535         ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 536             pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL),
 537             VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_GREATER));
 538         ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 539
 540         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 541         GetVersionExA((OSVERSIONINFOA *)&info);
 542         info.wServicePackMajor--;
 543         ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 544             pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL),
 545             VER_MINORVERSION, VER_LESS_EQUAL), VER_SERVICEPACKMAJOR, VER_GREATER));
 546         ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 547
 548         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 549         GetVersionExA((OSVERSIONINFOA *)&info);
 550         info.wServicePackMajor--;
 551         ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 552             pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL),
 553             VER_MINORVERSION, VER_AND), VER_SERVICEPACKMAJOR, VER_GREATER));
 554         ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 555     }
 556
 557     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 558     GetVersionExA((OSVERSIONINFOA *)&info);
 559     info.wServicePackMajor++;
 560     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 561         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_LESS_EQUAL), VER_SERVICEPACKMAJOR, VER_GREATER));
 562     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 563
 564     if (servicepack)
 565     {
 566         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 567         GetVersionExA((OSVERSIONINFOA *)&info);
 568         info.wServicePackMajor--;
 569         SetLastError(0xdeadbeef);
 570         ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 571             pVerSetConditionMask(pVerSetConditionMask(0, VER_SERVICEPACKMAJOR, VER_GREATER), VER_SERVICEPACKMINOR, VER_EQUAL));
 572         error = GetLastError();
 573         ok(!ret, "VerifyVersionInfoA succeeded\n");
 574         ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 575            "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 576     }
 577
 578     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 579     GetVersionExA((OSVERSIONINFOA *)&info);
 580     info.wServicePackMajor++;
 581     ret = pVerifyVersionInfoA(&info, VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 582         pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 583     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 584
 585     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 586     GetVersionExA((OSVERSIONINFOA *)&info);
 587     info.wServicePackMajor++;
 588     SetLastError(0xdeadbeef);
 589     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 590         pVerSetConditionMask(pVerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 591     error = GetLastError();
 592     ok(!ret, "VerifyVersionInfoA succeeded\n");
 593     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 594        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 595
 596     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 597     GetVersionExA((OSVERSIONINFOA *)&info);
 598     info.wServicePackMajor++;
 599     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 600         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 601     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 602
 603     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 604     GetVersionExA((OSVERSIONINFOA *)&info);
 605     info.wServicePackMajor++;
 606     SetLastError(0xdeadbeef);
 607     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 608         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 609     error = GetLastError();
 610     ok(!ret, "VerifyVersionInfoA succeeded\n");
 611     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 612        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 613
 614     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 615     GetVersionExA((OSVERSIONINFOA *)&info);
 616     info.wServicePackMajor++;
 617     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 618         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL),
 619         VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 620     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 621
 622     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 623     GetVersionExA((OSVERSIONINFOA *)&info);
 624     info.wServicePackMajor++;
 625     SetLastError(0xdeadbeef);
 626     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 627         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 628     error = GetLastError();
 629     ok(!ret, "VerifyVersionInfoA succeeded\n");
 630     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 631        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 632
 633     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 634     GetVersionExA((OSVERSIONINFOA *)&info);
 635     info.dwMajorVersion--;
 636     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 637         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 638     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 639
 640     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 641     GetVersionExA((OSVERSIONINFOA *)&info);
 642     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 643         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 644     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 645
 646     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 647     GetVersionExA((OSVERSIONINFOA *)&info);
 648     info.wServicePackMajor++;
 649     SetLastError(0xdeadbeef);
 650     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 651         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 652     error = GetLastError();
 653     ok(!ret, "VerifyVersionInfoA succeeded\n");
 654     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 655        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 656
 657     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 658     GetVersionExA((OSVERSIONINFOA *)&info);
 659     info.wServicePackMajor++;
 660     SetLastError(0xdeadbeef);
 661     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 662         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL),
 663         VER_MINORVERSION, VER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS));
 664     error = GetLastError();
 665     ok(!ret, "VerifyVersionInfoA succeeded\n");
 666     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 667        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 668
 669     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 670     GetVersionExA((OSVERSIONINFOA *)&info);
 671     info.wServicePackMajor++;
 672     SetLastError(0xdeadbeef);
 673     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 674         pVerSetConditionMask(pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL),
 675         VER_MINORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_LESS_EQUAL));
 676     error = GetLastError();
 677     ok(!ret, "VerifyVersionInfoA succeeded\n");
 678     ok(error == ERROR_OLD_WIN_VERSION || broken(error == ERROR_BAD_ARGUMENTS) /* some win2k */,
 679        "VerifyVersionInfoA should have failed with ERROR_OLD_WIN_VERSION instead of %d\n", error);
 680
 681     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 682     GetVersionExA((OSVERSIONINFOA *)&info);
 683     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 684         pVerSetConditionMask(pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_SERVICEPACKMAJOR, VER_AND));
 685     ok(ret, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 686
 687     /* test bad dwOSVersionInfoSize */
 688     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
 689     GetVersionExA((OSVERSIONINFOA *)&info);
 690     info.dwOSVersionInfoSize = 0;
 691     ret = pVerifyVersionInfoA(&info, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
 692         pVerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL));
 693     ok(ret || broken(!ret) /* some win2k */, "VerifyVersionInfoA failed with error %d\n", GetLastError());
 694 }
 695
 696 START_TEST(version)
 697 {
 698     init_function_pointers();
 699
 700     test_GetProductInfo();
 701     test_GetVersionEx();
 702     test_VerifyVersionInfo();
 703 }