modules/rostests/apitests/appshim/versionlie.c

   1 /*
   2  * PROJECT:     appshim_apitest
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     Tests for versionlie shims
   5  * COPYRIGHT:   Copyright 2015-2018 Mark Jansen (mark.jansen@reactos.org)
   6  */
   7
   8 #include <ntstatus.h>
   9 #define WIN32_NO_STATUS
  10 #include <windows.h>
  11 #ifdef __REACTOS__
  12 #include <ntndk.h>
  13 #else
  14 #include <winternl.h>
  15 #endif
  16 #include "wine/test.h"
  17 #include <strsafe.h>
  18
  19 #include "appshim_apitest.h"
  20
  21 static tGETHOOKAPIS pGetHookAPIs;
  22
  23
  24 static DWORD g_WinVersion;
  25 #define WINVER_WINXP   0x0501
  26
  27
  28 typedef struct VersionLieInfo
  29 {
  30     DWORD FullVersion;
  31     DWORD dwMajorVersion;
  32     DWORD dwMinorVersion;
  33     DWORD dwBuildNumber;
  34     DWORD dwPlatformId;
  35     WORD wServicePackMajor;
  36     WORD wServicePackMinor;
  37 } VersionLieInfo;
  38
  39 typedef BOOL(WINAPI* GETVERSIONEXAPROC)(LPOSVERSIONINFOEXA);
  40 typedef BOOL(WINAPI* GETVERSIONEXWPROC)(LPOSVERSIONINFOEXW);
  41 typedef DWORD(WINAPI* GETVERSIONPROC)(void);
  42
  43 void expect_shim_imp(PHOOKAPI hook, PCSTR library, PCSTR function, PCSTR shim, int* same)
  44 {
  45     int lib = lstrcmpA(library, hook->LibraryName);
  46     int fn = lstrcmpA(function, hook->FunctionName);
  47     winetest_ok(lib == 0, "Expected LibrarayName to be %s, was: %s for %s\n", library, hook->LibraryName, shim);
  48     winetest_ok(fn == 0, "Expected FunctionName to be %s, was: %s for %s\n", function, hook->FunctionName, shim);
  49     *same = (lib == 0 && fn == 0);
  50 }
  51
  52 static void verify_shima_imp(PHOOKAPI hook, const VersionLieInfo* info, PCSTR shim, int same)
  53 {
  54     OSVERSIONINFOEXA v1 = { sizeof(v1), 0 }, v2 = { sizeof(v2), 0 };
  55     BOOL ok1, ok2;
  56
  57     if (!same)
  58     {
  59         skip("Skipping implementation tests for %s\n", shim);
  60         return;
  61     }
  62
  63     while (v1.dwOSVersionInfoSize)
  64     {
  65         ok1 = GetVersionExA((LPOSVERSIONINFOA)&v1);
  66         hook->OriginalFunction = GetVersionExA;
  67
  68         ok2 = ((GETVERSIONEXAPROC)hook->ReplacementFunction)(&v2);
  69
  70         winetest_ok(ok1 == ok2, "Expected ok1 to equal ok2, was: %i, %i for %s\n", ok1, ok2, shim);
  71         if (ok1 && ok2)
  72         {
  73             char szCSDVersion[128] = "";
  74             winetest_ok(v1.dwOSVersionInfoSize == v2.dwOSVersionInfoSize, "Expected dwOSVersionInfoSize to be equal, was: %u, %u for %s\n", v1.dwOSVersionInfoSize, v2.dwOSVersionInfoSize, shim);
  75             winetest_ok(info->dwMajorVersion == v2.dwMajorVersion, "Expected dwMajorVersion to be equal, was: %u, %u for %s\n", info->dwMajorVersion, v2.dwMajorVersion, shim);
  76             winetest_ok(info->dwMinorVersion == v2.dwMinorVersion, "Expected dwMinorVersion to be equal, was: %u, %u for %s\n", info->dwMinorVersion, v2.dwMinorVersion, shim);
  77             winetest_ok(info->dwBuildNumber == v2.dwBuildNumber, "Expected dwBuildNumber to be equal, was: %u, %u for %s\n", info->dwBuildNumber, v2.dwBuildNumber, shim);
  78             winetest_ok(info->dwPlatformId == v2.dwPlatformId, "Expected dwPlatformId to be equal, was: %u, %u for %s\n", info->dwPlatformId, v2.dwPlatformId, shim);
  79
  80             if (info->wServicePackMajor)
  81                 StringCchPrintfA(szCSDVersion, _countof(szCSDVersion), "Service Pack %u", info->wServicePackMajor);
  82             winetest_ok(lstrcmpA(szCSDVersion, v2.szCSDVersion) == 0, "Expected szCSDVersion to be equal, was: %s, %s for %s\n", szCSDVersion, v2.szCSDVersion, shim);
  83
  84             if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXA))
  85             {
  86                 if (info->dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
  87                 {
  88                     winetest_ok(info->wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", info->wServicePackMajor, v2.wServicePackMajor, shim);
  89                     winetest_ok(info->wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", info->wServicePackMinor, v2.wServicePackMinor, shim);
  90                 }
  91                 else
  92                 {
  93                     winetest_ok(v1.wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
  94                     winetest_ok(v1.wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
  95                 }
  96                 winetest_ok(v1.wSuiteMask == v2.wSuiteMask, "Expected wSuiteMask to be equal, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
  97                 winetest_ok(v1.wProductType == v2.wProductType, "Expected wProductType to be equal, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
  98                 winetest_ok(v1.wReserved == v2.wReserved, "Expected wReserved to be equal, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
  99             }
 100             else
 101             {
 102                 winetest_ok(v1.wServicePackMajor == 0 && v2.wServicePackMajor == 0, "Expected wServicePackMajor to be 0, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
 103                 winetest_ok(v1.wServicePackMinor == 0 && v2.wServicePackMinor == 0, "Expected wServicePackMinor to be 0, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
 104                 winetest_ok(v1.wSuiteMask == 0 && v2.wSuiteMask == 0, "Expected wSuiteMask to be 0, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
 105                 winetest_ok(v1.wProductType == 0 && v2.wProductType == 0, "Expected wProductType to be 0, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
 106                 winetest_ok(v1.wReserved == 0 && v2.wReserved == 0, "Expected wReserved to be 0, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
 107             }
 108         }
 109
 110         ZeroMemory(&v1, sizeof(v1));
 111         ZeroMemory(&v2, sizeof(v2));
 112         if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXA))
 113             v1.dwOSVersionInfoSize = v2.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
 114     }
 115 }
 116
 117 static void verify_shimw_imp(PHOOKAPI hook, const VersionLieInfo* info, PCSTR shim, int same, int first_might_be_broken)
 118 {
 119     OSVERSIONINFOEXW v1 = { sizeof(v1), 0 }, v2 = { sizeof(v2), 0 };
 120     BOOL ok1, ok2, first = TRUE;
 121
 122     if (!same)
 123     {
 124         skip("Skipping implementation tests for %s\n", shim);
 125         return;
 126     }
 127
 128     while (v1.dwOSVersionInfoSize)
 129     {
 130         ok1 = GetVersionExW((LPOSVERSIONINFOW)&v1);
 131         hook->OriginalFunction = GetVersionExW;
 132
 133         ok2 = ((GETVERSIONEXWPROC)hook->ReplacementFunction)(&v2);
 134
 135         if (first_might_be_broken && first && ok1 == TRUE && ok2 == FALSE)
 136         {
 137             skip("Skipping first check because 0x%x is (falsely) not accepted by the shim %s\n", sizeof(v1), shim);
 138         }
 139         else
 140         {
 141             winetest_ok(ok1 == ok2, "Expected ok1 to equal ok2, was: %i, %i for %s(first:%d)\n", ok1, ok2, shim, first);
 142         }
 143         if (ok1 && ok2)
 144         {
 145             WCHAR szCSDVersion[128] = { 0 };
 146             winetest_ok(v1.dwOSVersionInfoSize == v2.dwOSVersionInfoSize, "Expected dwOSVersionInfoSize to be equal, was: %u, %u for %s\n", v1.dwOSVersionInfoSize, v2.dwOSVersionInfoSize, shim);
 147             winetest_ok(info->dwMajorVersion == v2.dwMajorVersion, "Expected dwMajorVersion to be equal, was: %u, %u for %s\n", info->dwMajorVersion, v2.dwMajorVersion, shim);
 148             winetest_ok(info->dwMinorVersion == v2.dwMinorVersion, "Expected dwMinorVersion to be equal, was: %u, %u for %s\n", info->dwMinorVersion, v2.dwMinorVersion, shim);
 149             winetest_ok(info->dwBuildNumber == v2.dwBuildNumber, "Expected dwBuildNumber to be equal, was: %u, %u for %s\n", info->dwBuildNumber, v2.dwBuildNumber, shim);
 150             winetest_ok(info->dwPlatformId == v2.dwPlatformId, "Expected dwPlatformId to be equal, was: %u, %u for %s\n", info->dwPlatformId, v2.dwPlatformId, shim);
 151
 152             if (info->wServicePackMajor)
 153                 StringCchPrintfW(szCSDVersion, _countof(szCSDVersion), L"Service Pack %u", info->wServicePackMajor);
 154             winetest_ok(lstrcmpW(szCSDVersion, v2.szCSDVersion) == 0, "Expected szCSDVersion to be equal, was: %s, %s for %s\n", wine_dbgstr_w(szCSDVersion), wine_dbgstr_w(v2.szCSDVersion), shim);
 155
 156             if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXW))
 157             {
 158                 if (info->dwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
 159                 {
 160                     winetest_ok(info->wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", info->wServicePackMajor, v2.wServicePackMajor, shim);
 161                     winetest_ok(info->wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", info->wServicePackMinor, v2.wServicePackMinor, shim);
 162                 }
 163                 else
 164                 {
 165                     winetest_ok(v1.wServicePackMajor == v2.wServicePackMajor, "Expected wServicePackMajor to be equal, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
 166                     winetest_ok(v1.wServicePackMinor == v2.wServicePackMinor, "Expected wServicePackMinor to be equal, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
 167                 }
 168                 winetest_ok(v1.wSuiteMask == v2.wSuiteMask, "Expected wSuiteMask to be equal, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
 169                 winetest_ok(v1.wProductType == v2.wProductType, "Expected wProductType to be equal, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
 170                 winetest_ok(v1.wReserved == v2.wReserved, "Expected wReserved to be equal, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
 171             }
 172             else
 173             {
 174                 winetest_ok(v1.wServicePackMajor == 0 && v2.wServicePackMajor == 0, "Expected wServicePackMajor to be 0, was: %i, %i for %s\n", v1.wServicePackMajor, v2.wServicePackMajor, shim);
 175                 winetest_ok(v1.wServicePackMinor == 0 && v2.wServicePackMinor == 0, "Expected wServicePackMinor to be 0, was: %i, %i for %s\n", v1.wServicePackMinor, v2.wServicePackMinor, shim);
 176                 winetest_ok(v1.wSuiteMask == 0 && v2.wSuiteMask == 0, "Expected wSuiteMask to be 0, was: %i, %i for %s\n", v1.wSuiteMask, v2.wSuiteMask, shim);
 177                 winetest_ok(v1.wProductType == 0 && v2.wProductType == 0, "Expected wProductType to be 0, was: %i, %i for %s\n", v1.wProductType, v2.wProductType, shim);
 178                 winetest_ok(v1.wReserved == 0 && v2.wReserved == 0, "Expected wReserved to be 0, was: %i, %i for %s\n", v1.wReserved, v2.wReserved, shim);
 179             }
 180         }
 181
 182         ZeroMemory(&v1, sizeof(v1));
 183         ZeroMemory(&v2, sizeof(v2));
 184         if (v1.dwOSVersionInfoSize == sizeof(OSVERSIONINFOEXW))
 185             v1.dwOSVersionInfoSize = v2.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
 186         first = FALSE;
 187     }
 188 }
 189
 190 static void verify_shim_imp(PHOOKAPI hook, const VersionLieInfo* info, PCSTR shim, int same)
 191 {
 192     DWORD ver;
 193     if (!same)
 194     {
 195         skip("Skipping implementation tests for %s\n", shim);
 196         return;
 197     }
 198     ver = ((GETVERSIONPROC)hook->ReplacementFunction)();
 199     winetest_ok(info->FullVersion == ver, "Expected GetVersion to return 0x%x, was: 0x%x for %s\n", info->FullVersion, ver, shim);
 200 }
 201
 202
 203 #define verify_shima  (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : verify_shima_imp
 204 #define verify_shimw  (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : verify_shimw_imp
 205 #define verify_shim  (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : verify_shim_imp
 206
 207
 208
 209
 210 static void run_test(LPCSTR shim, const VersionLieInfo* info)
 211 {
 212     DWORD num_shims = 0;
 213     WCHAR wide_shim[50] = { 0 };
 214     PHOOKAPI hook;
 215     DWORD ver;
 216     MultiByteToWideChar(CP_ACP, 0, shim, -1, wide_shim, 50);
 217     hook = pGetHookAPIs("", wide_shim, &num_shims);
 218     ver = (info->dwMajorVersion << 8) | info->dwMinorVersion;
 219     if (hook == NULL)
 220     {
 221         skip("Skipping tests for layers (%s) not present in this os (0x%x)\n", shim, g_WinVersion);
 222         return;
 223     }
 224     ok(hook != NULL, "Expected hook to be a valid pointer for %s\n", shim);
 225     if (info->dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
 226     {
 227         ok(num_shims == 3, "Expected num_shims to be 3, was: %u for %s\n", num_shims, shim);
 228         if (hook && num_shims == 3)
 229         {
 230             int off = info->dwBuildNumber == 0x040A08AE ? 0 : 1, same = 0;
 231             expect_shim(hook + ((0+off)%3), "KERNEL32.DLL", "GetVersionExA", shim, &same);
 232             verify_shima(hook + ((0+off)%3), info, shim, same);
 233             expect_shim(hook + ((1+off)%3), "KERNEL32.DLL", "GetVersionExW", shim, &same);
 234             verify_shimw(hook + ((1+off)%3), info, shim, same, 0);
 235             expect_shim(hook + ((2+off)%3), "KERNEL32.DLL", "GetVersion", shim, &same);
 236             verify_shim(hook + ((2+off)%3), info, shim, same);
 237         }
 238     }
 239     else
 240     {
 241         int shimnum_ok = num_shims == 4 || ((ver < WINVER_WINXP) && (num_shims == 3));
 242         ok(shimnum_ok, "Expected num_shims to be 4%s, was: %u for %s\n", ((ver < WINVER_WINXP) ? " or 3":""), num_shims, shim);
 243         if (hook && shimnum_ok)
 244         {
 245             int same = 0;
 246             expect_shim(hook + 0, "KERNEL32.DLL", "GetVersionExA", shim, &same);
 247             verify_shima(hook + 0, info, shim, same);
 248             expect_shim(hook + 1, "KERNEL32.DLL", "GetVersionExW", shim, &same);
 249             verify_shimw(hook + 1, info, shim, same, 0);
 250             expect_shim(hook + 2, "KERNEL32.DLL", "GetVersion", shim, &same);
 251             verify_shim(hook + 2, info, shim, same);
 252             if (num_shims == 4)
 253             {
 254                 expect_shim(hook + 3, "NTDLL.DLL", "RtlGetVersion", shim, &same);
 255                 verify_shimw(hook + 3, info, shim, same, 1);
 256             }
 257         }
 258     }
 259 }
 260
 261
 262 VersionLieInfo g_Win95 = { 0xC3B60004, 4, 0, 950, VER_PLATFORM_WIN32_WINDOWS, 0, 0 };
 263 VersionLieInfo g_WinNT4SP5 = { 0x05650004, 4, 0, 1381, VER_PLATFORM_WIN32_NT, 5, 0 };
 264 VersionLieInfo g_Win98 = { 0xC0000A04, 4, 10, 0x040A08AE, VER_PLATFORM_WIN32_WINDOWS, 0, 0 };
 265
 266 VersionLieInfo g_Win2000 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 0, 0 };
 267 VersionLieInfo g_Win2000SP1 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 1, 0 };
 268 VersionLieInfo g_Win2000SP2 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 2, 0 };
 269 VersionLieInfo g_Win2000SP3 = { 0x08930005, 5, 0, 2195, VER_PLATFORM_WIN32_NT, 3, 0 };
 270
 271 VersionLieInfo g_WinXP = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 0, 0 };
 272 VersionLieInfo g_WinXPSP1 = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 1, 0 };
 273 VersionLieInfo g_WinXPSP2 = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 2, 0 };
 274 VersionLieInfo g_WinXPSP3 = { 0x0a280105, 5, 1, 2600, VER_PLATFORM_WIN32_NT, 3, 0 };
 275
 276 VersionLieInfo g_Win2k3RTM = { 0x0ece0205, 5, 2, 3790, VER_PLATFORM_WIN32_NT, 0, 0 };
 277 VersionLieInfo g_Win2k3SP1 = { 0x0ece0205, 5, 2, 3790, VER_PLATFORM_WIN32_NT, 1, 0 };
 278
 279 VersionLieInfo g_WinVistaRTM = { 0x17700006, 6, 0, 6000, VER_PLATFORM_WIN32_NT, 0, 0 };
 280 VersionLieInfo g_WinVistaSP1 = { 0x17710006, 6, 0, 6001, VER_PLATFORM_WIN32_NT, 1, 0 };
 281 VersionLieInfo g_WinVistaSP2 = { 0x17720006, 6, 0, 6002, VER_PLATFORM_WIN32_NT, 2, 0 };
 282
 283 VersionLieInfo g_Win7RTM = { 0x1db00106, 6, 1, 7600, VER_PLATFORM_WIN32_NT, 0, 0 };
 284 VersionLieInfo g_Win7SP1 = { 0x1db10106, 6, 1, 7601, VER_PLATFORM_WIN32_NT, 1, 0 }; /* ReactOS specific. Windows does not have  this version lie */
 285
 286 VersionLieInfo g_Win8RTM = { 0x23f00206, 6, 2, 9200, VER_PLATFORM_WIN32_NT, 0, 0 };
 287 VersionLieInfo g_Win81RTM = { 0x25800306, 6, 3, 9600, VER_PLATFORM_WIN32_NT, 0, 0 };
 288
 289
 290 DWORD get_host_winver(void)
 291 {
 292     RTL_OSVERSIONINFOEXW rtlinfo = {0};
 293     void (__stdcall* pRtlGetVersion)(RTL_OSVERSIONINFOEXW*);
 294     pRtlGetVersion = (void (__stdcall*)(RTL_OSVERSIONINFOEXW*))GetProcAddress(GetModuleHandleA("ntdll"), "RtlGetVersion");
 295
 296     rtlinfo.dwOSVersionInfoSize = sizeof(rtlinfo);
 297     pRtlGetVersion(&rtlinfo);
 298     return (rtlinfo.dwMajorVersion << 8) | rtlinfo.dwMinorVersion;
 299 }
 300
 301 BOOL LoadShimDLL(PCWSTR ShimDll, HMODULE* module, tGETHOOKAPIS* ppGetHookAPIs)
 302 {
 303     static tSDBGETAPPPATCHDIR pSdbGetAppPatchDir = NULL;
 304     HMODULE dll;
 305     WCHAR buf[MAX_PATH] = {0};
 306     if (!pSdbGetAppPatchDir)
 307     {
 308         dll = LoadLibraryA("apphelp.dll");
 309         pSdbGetAppPatchDir = (tSDBGETAPPPATCHDIR)GetProcAddress(dll, "SdbGetAppPatchDir");
 310
 311         if (!pSdbGetAppPatchDir)
 312         {
 313             skip("Unable to retrieve SdbGetAppPatchDir (%p, %p)\n", dll, pSdbGetAppPatchDir);
 314         }
 315     }
 316
 317     if (!pSdbGetAppPatchDir || !SUCCEEDED(pSdbGetAppPatchDir(NULL, buf, MAX_PATH)))
 318     {
 319         skip("Unable to retrieve AppPatch dir, building manually\n");
 320         if (!GetSystemWindowsDirectoryW(buf, MAX_PATH))
 321         {
 322             skip("Unable to build AppPatch name(1)\n");
 323             return FALSE;
 324         }
 325         if (!SUCCEEDED(StringCchCatW(buf, _countof(buf), L"\\AppPatch")))
 326         {
 327             skip("Unable to build AppPatch name(2)\n");
 328             return FALSE;
 329         }
 330     }
 331     if (!SUCCEEDED(StringCchCatW(buf, _countof(buf), L"\\")) ||
 332         !SUCCEEDED(StringCchCatW(buf, _countof(buf), ShimDll)))
 333     {
 334         skip("Unable to append dll name\n");
 335         return FALSE;
 336     }
 337
 338     dll = LoadLibraryW(buf);
 339     if (!dll)
 340     {
 341         skip("Unable to load shim dll from AppPatch\n");
 342         GetSystemWindowsDirectoryW(buf, _countof(buf));
 343
 344         if (SUCCEEDED(StringCchCatW(buf, _countof(buf), L"\\System32\\")) &&
 345             SUCCEEDED(StringCchCatW(buf, _countof(buf), ShimDll)))
 346         {
 347             dll = LoadLibraryW(buf);
 348         }
 349
 350         if (!dll)
 351         {
 352             skip("Unable to load shim dll from System32 (Recent Win10)\n");
 353             return FALSE;
 354         }
 355     }
 356     *module = dll;
 357     *ppGetHookAPIs = (tGETHOOKAPIS)GetProcAddress(dll, "GetHookAPIs");
 358
 359     return *ppGetHookAPIs != NULL;
 360 }
 361
 362
 363 tGETHOOKAPIS LoadShimDLL2(PCWSTR ShimDll)
 364 {
 365     HMODULE module;
 366     tGETHOOKAPIS pGetHookAPIs;
 367
 368     if (LoadShimDLL(ShimDll, &module, &pGetHookAPIs))
 369     {
 370         if (!pGetHookAPIs)
 371             skip("No GetHookAPIs found\n");
 372         return pGetHookAPIs;
 373     }
 374     return NULL;
 375 }
 376
 377
 378 START_TEST(versionlie)
 379 {
 380     pGetHookAPIs = LoadShimDLL2(L"aclayers.dll");
 381
 382     if (!pGetHookAPIs)
 383         return;
 384
 385     g_WinVersion = get_host_winver();
 386
 387     run_test("Win95VersionLie", &g_Win95);
 388     run_test("WinNT4SP5VersionLie", &g_WinNT4SP5);
 389     run_test("Win98VersionLie", &g_Win98);
 390     run_test("Win2000VersionLie", &g_Win2000);
 391     run_test("Win2000SP1VersionLie", &g_Win2000SP1);
 392     run_test("Win2000SP2VersionLie", &g_Win2000SP2);
 393     run_test("Win2000SP3VersionLie", &g_Win2000SP3);
 394     run_test("WinXPVersionLie", &g_WinXP);
 395     run_test("WinXPSP1VersionLie", &g_WinXPSP1);
 396     run_test("WinXPSP2VersionLie", &g_WinXPSP2);
 397     run_test("WinXPSP3VersionLie", &g_WinXPSP3);
 398     run_test("Win2k3RTMVersionLie", &g_Win2k3RTM);
 399     run_test("Win2k3SP1VersionLie", &g_Win2k3SP1);
 400     run_test("VistaRTMVersionLie", &g_WinVistaRTM);
 401     run_test("VistaSP1VersionLie", &g_WinVistaSP1);
 402     run_test("VistaSP2VersionLie", &g_WinVistaSP2);
 403     run_test("Win7RTMVersionLie", &g_Win7RTM);
 404     run_test("Win7SP1VersionLie", &g_Win7SP1);    /* ReactOS specific. Windows does not have this version lie */
 405     run_test("Win8RTMVersionLie", &g_Win8RTM);
 406     run_test("Win81RTMVersionLie", &g_Win81RTM);
 407 }