modules/rostests/apitests/apphelp/apphelp.c

   1 /*
   2  * PROJECT:     apphelp_apitest
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     Misc apphelp tests
   5  * COPYRIGHT:   Copyright 2012 Detlef Riekenberg
   6  *              Copyright 2013 Mislav Blažević
   7  *              Copyright 2015-2017 Mark Jansen (mark.jansen@reactos.org)
   8  */
   9
  10 #include <ntstatus.h>
  11 #define WIN32_NO_STATUS
  12 #include <windows.h>
  13 #include <shlwapi.h>
  14 #include <winnt.h>
  15 #ifdef __REACTOS__
  16 #include <ntndk.h>
  17 #else
  18 #include <winternl.h>
  19 #endif
  20
  21 #include <winerror.h>
  22 #include <stdio.h>
  23 #include <initguid.h>
  24 #include <shlguid.h>
  25 #include <shobjidl.h>
  26
  27 #include "wine/test.h"
  28
  29 #include "apphelp_apitest.h"
  30
  31
  32 #define TAG_TYPE_MASK 0xF000
  33
  34 #define TAG_TYPE_NULL 0x1000
  35 #define TAG_TYPE_BYTE 0x2000
  36 #define TAG_TYPE_WORD 0x3000
  37 #define TAG_TYPE_DWORD 0x4000
  38 #define TAG_TYPE_QWORD 0x5000
  39 #define TAG_TYPE_STRINGREF 0x6000
  40 #define TAG_TYPE_LIST 0x7000
  41 #define TAG_TYPE_STRING 0x8000
  42 #define TAG_TYPE_BINARY 0x9000
  43 #define TAG_NULL 0x0
  44 #define TAG_SIZE (0x1 | TAG_TYPE_DWORD)
  45 #define TAG_CHECKSUM (0x3 | TAG_TYPE_DWORD)
  46 #define TAG_MODULE_TYPE (0x6 | TAG_TYPE_DWORD)
  47 #define TAG_VERDATEHI (0x7 | TAG_TYPE_DWORD)
  48 #define TAG_VERDATELO (0x8 | TAG_TYPE_DWORD)
  49 #define TAG_VERFILEOS (0x9 | TAG_TYPE_DWORD)
  50 #define TAG_VERFILETYPE (0xA | TAG_TYPE_DWORD)
  51 #define TAG_PE_CHECKSUM (0xB | TAG_TYPE_DWORD)
  52 #define TAG_VER_LANGUAGE (0x12 | TAG_TYPE_DWORD)
  53 #define TAG_LINKER_VERSION (0x1C | TAG_TYPE_DWORD)
  54 #define TAG_LINK_DATE (0x1D | TAG_TYPE_DWORD)
  55 #define TAG_UPTO_LINK_DATE (0x1E | TAG_TYPE_DWORD)
  56 #define TAG_EXE_WRAPPER (0x31 | TAG_TYPE_DWORD)
  57 #define TAG_BIN_FILE_VERSION (0x2 | TAG_TYPE_QWORD)
  58 #define TAG_BIN_PRODUCT_VERSION (0x3 | TAG_TYPE_QWORD)
  59 #define TAG_UPTO_BIN_PRODUCT_VERSION (0x6 | TAG_TYPE_QWORD)
  60 #define TAG_UPTO_BIN_FILE_VERSION (0xD | TAG_TYPE_QWORD)
  61 #define TAG_NAME (0x1 | TAG_TYPE_STRINGREF)
  62 #define TAG_COMPANY_NAME (0x9 | TAG_TYPE_STRINGREF)
  63 #define TAG_PRODUCT_NAME (0x10 | TAG_TYPE_STRINGREF)
  64 #define TAG_PRODUCT_VERSION (0x11 | TAG_TYPE_STRINGREF)
  65 #define TAG_FILE_DESCRIPTION (0x12 | TAG_TYPE_STRINGREF)
  66 #define TAG_FILE_VERSION (0x13 | TAG_TYPE_STRINGREF)
  67 #define TAG_ORIGINAL_FILENAME (0x14 | TAG_TYPE_STRINGREF)
  68 #define TAG_INTERNAL_NAME (0x15 | TAG_TYPE_STRINGREF)
  69 #define TAG_LEGAL_COPYRIGHT (0x16 | TAG_TYPE_STRINGREF)
  70 #define TAG_16BIT_DESCRIPTION (0x17 | TAG_TYPE_STRINGREF)
  71 #define TAG_16BIT_MODULE_NAME (0x20 | TAG_TYPE_STRINGREF)
  72 #define TAG_EXPORT_NAME (0x24 | TAG_TYPE_STRINGREF)
  73
  74
  75 #define ATTRIBUTE_AVAILABLE 0x1
  76 #define ATTRIBUTE_FAILED 0x2
  77
  78 typedef struct tagATTRINFO {
  79   TAG   type;
  80   DWORD flags;  /* ATTRIBUTE_AVAILABLE, ATTRIBUTE_FAILED */
  81   union {
  82     QWORD qwattr;
  83     DWORD dwattr;
  84     WCHAR *lpattr;
  85   };
  86 } ATTRINFO, *PATTRINFO;
  87
  88 static HMODULE hdll;
  89 static BOOL (WINAPI *pApphelpCheckShellObject)(REFCLSID, BOOL, ULONGLONG *);
  90 static LPCWSTR (WINAPI *pSdbTagToString)(TAG tag);
  91 static BOOL (WINAPI *pSdbGUIDToString)(REFGUID Guid, PWSTR GuidString, SIZE_T Length);
  92 static BOOL (WINAPI *pSdbIsNullGUID)(REFGUID Guid);
  93 static BOOL (WINAPI *pSdbGetStandardDatabaseGUID)(DWORD Flags, GUID* Guid);
  94 static BOOL (WINAPI *pSdbGetFileAttributes)(LPCWSTR wszPath, PATTRINFO *ppAttrInfo, LPDWORD pdwAttrCount);
  95 static BOOL (WINAPI *pSdbFreeFileAttributes)(PATTRINFO AttrInfo);
  96 static HRESULT (WINAPI* pSdbGetAppPatchDir)(PVOID hsdb, LPWSTR path, DWORD size);
  97
  98 /* 'Known' database guids */
  99 DEFINE_GUID(GUID_DATABASE_MSI,0xd8ff6d16,0x6a3a,0x468a,0x8b,0x44,0x01,0x71,0x4d,0xdc,0x49,0xea);
 100 DEFINE_GUID(GUID_DATABASE_SHIM,0x11111111,0x1111,0x1111,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11);
 101 DEFINE_GUID(GUID_DATABASE_DRIVERS,0xf9ab2228,0x3312,0x4a73,0xb6,0xf9,0x93,0x6d,0x70,0xe1,0x12,0xef);
 102
 103 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
 104
 105 DEFINE_GUID(test_Microsoft_Browser_Architecture, 0xa5e46e3a, 0x8849, 0x11d1, 0x9d, 0x8c, 0x00, 0xc0, 0x4f, 0xc9, 0x9d, 0x61);
 106 DEFINE_GUID(test_UserAssist, 0xdd313e04, 0xfeff, 0x11d1, 0x8e, 0xcd, 0x00, 0x00, 0xf8, 0x7a, 0x47, 0x0c);
 107 DEFINE_GUID(CLSID_InternetSecurityManager, 0x7b8a2d94, 0x0ac9, 0x11d1, 0x89, 0x6c, 0x00, 0xc0, 0x4f, 0xB6, 0xbf, 0xc4);
 108
 109 static const CLSID * objects[] = {
 110     &GUID_NULL,
 111     /* used by IE */
 112     &test_Microsoft_Browser_Architecture,
 113     &CLSID_MenuBand,
 114     &CLSID_ShellLink,
 115     &CLSID_ShellWindows,
 116     &CLSID_InternetSecurityManager,
 117     &test_UserAssist,
 118     (const CLSID *)NULL
 119 };
 120
 121 static void test_ApphelpCheckShellObject(void)
 122 {
 123     ULONGLONG flags;
 124     BOOL res;
 125     int i;
 126
 127     if (!pApphelpCheckShellObject)
 128     {
 129         win_skip("ApphelpCheckShellObject not available\n");
 130         return;
 131     }
 132
 133     for (i = 0; objects[i]; i++)
 134     {
 135         flags = 0xdeadbeef;
 136         SetLastError(0xdeadbeef);
 137         res = pApphelpCheckShellObject(objects[i], FALSE, &flags);
 138         ok(res && (flags == 0), "%s 0: got %d and 0x%x%08x with 0x%x (expected TRUE and 0)\n",
 139             wine_dbgstr_guid(objects[i]), res, (ULONG)(flags >> 32), (ULONG)flags, GetLastError());
 140
 141         flags = 0xdeadbeef;
 142         SetLastError(0xdeadbeef);
 143         res = pApphelpCheckShellObject(objects[i], TRUE, &flags);
 144         ok(res && (flags == 0), "%s 1: got %d and 0x%x%08x with 0x%x (expected TRUE and 0)\n",
 145             wine_dbgstr_guid(objects[i]), res, (ULONG)(flags >> 32), (ULONG)flags, GetLastError());
 146
 147     }
 148
 149     /* NULL as pointer to flags is checked */
 150     SetLastError(0xdeadbeef);
 151     res = pApphelpCheckShellObject(&GUID_NULL, FALSE, NULL);
 152     ok(res, "%s 0: got %d with 0x%x (expected != FALSE)\n", wine_dbgstr_guid(&GUID_NULL), res, GetLastError());
 153
 154     /* NULL as CLSID* crash on Windows */
 155     if (0)
 156     {
 157         flags = 0xdeadbeef;
 158         SetLastError(0xdeadbeef);
 159         res = pApphelpCheckShellObject(NULL, FALSE, &flags);
 160         trace("NULL as CLSID*: got %d and 0x%x%08x with 0x%x\n", res, (ULONG)(flags >> 32), (ULONG)flags, GetLastError());
 161     }
 162 }
 163
 164 static void test_SdbTagToString(void)
 165 {
 166     static const TAG invalid_values[] = {
 167         1, TAG_TYPE_WORD, TAG_TYPE_MASK,
 168         TAG_TYPE_DWORD | 0xFF,
 169         TAG_TYPE_DWORD | (0x800 + 0xEE),
 170         0x900, 0xFFFF, 0xDEAD, 0xBEEF
 171     };
 172     static const WCHAR invalid[] = {'I','n','v','a','l','i','d','T','a','g',0};
 173     LPCWSTR ret;
 174     WORD i;
 175
 176     for (i = 0; i < 9; ++i)
 177     {
 178         ret = pSdbTagToString(invalid_values[i]);
 179         ok(lstrcmpW(ret, invalid) == 0, "unexpected string %s, should be %s\n",
 180            wine_dbgstr_w(ret), wine_dbgstr_w(invalid));
 181     }
 182 }
 183
 184 static int strcmp_wa(LPCWSTR strw, const char *stra)
 185 {
 186     CHAR buf[512];
 187     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), 0, 0);
 188     return lstrcmpA(buf, stra);
 189 }
 190
 191 void test_tag(TAG base, const char* names[], size_t upperlimit, int line)
 192 {
 193     TAG n;
 194     for (n = 0; names[n]; ++n)
 195     {
 196         LPCWSTR tagstr = pSdbTagToString(base | n);
 197         ok_(__FILE__, line + 2)(!strcmp_wa(tagstr, names[n]), "Got %s instead of '%s' for %x\n", wine_dbgstr_w(tagstr), names[n], base | n);
 198     }
 199     for (; n < upperlimit; ++n)
 200     {
 201         LPCWSTR tagstr = pSdbTagToString(base | n);
 202         ok_(__FILE__, line + 2)(!strcmp_wa(tagstr, "InvalidTag"), "Got %s instead of 'InvalidTag' for %x\n", wine_dbgstr_w(tagstr), base | n);
 203     }
 204 }
 205
 206 static struct
 207 {
 208     TAG base;
 209     DWORD upper_limit;
 210     DWORD line;
 211     DWORD min_ver;
 212     DWORD max_ver;
 213     const char* tags[7*8];
 214 } data[] = {
 215     {
 216         TAG_TYPE_NULL, 0x1000, __LINE__, WINVER_ANY, WINVER_2003,
 217         {
 218             "InvalidTag", "INCLUDE", "GENERAL", "MATCH_LOGIC_NOT", "APPLY_ALL_SHIMS", "USE_SERVICE_PACK_FILES", NULL
 219         }
 220     },
 221     {
 222         TAG_TYPE_NULL, 0x1000, __LINE__, WINVER_VISTA, WINVER_VISTA,
 223         {
 224             "InvalidTag", "INCLUDE", "GENERAL", "MATCH_LOGIC_NOT", "APPLY_ALL_SHIMS", "USE_SERVICE_PACK_FILES", "MITIGATION_OS", "BLOCK_UPGRADE",
 225             "INCLUDEEXCLUDEDLL", NULL
 226         }
 227     },
 228     {
 229         TAG_TYPE_NULL, 0x1000, __LINE__, WINVER_WIN7, WINVER_ANY,
 230         {
 231             "InvalidTag", "INCLUDE", "GENERAL", "MATCH_LOGIC_NOT", "APPLY_ALL_SHIMS", "USE_SERVICE_PACK_FILES", "MITIGATION_OS", "BLOCK_UPGRADE",
 232             "INCLUDEEXCLUDEDLL", "RAC_EVENT_OFF", "TELEMETRY_OFF", "SHIM_ENGINE_OFF", "LAYER_PROPAGATION_OFF", "REINSTALL_UPGRADE", NULL
 233         }
 234     },
 235
 236     {
 237         TAG_TYPE_BYTE, 0x1000, __LINE__, WINVER_ANY, WINVER_ANY,
 238         {
 239             "InvalidTag", NULL
 240         }
 241     },
 242
 243     {
 244         TAG_TYPE_WORD, 0x800, __LINE__, WINVER_ANY, WINVER_WIN7,
 245         {
 246             "InvalidTag", "MATCH_MODE", NULL
 247         }
 248     },
 249     {
 250         TAG_TYPE_WORD, 0x800, __LINE__, WINVER_WIN8, WINVER_ANY,
 251         {
 252             "InvalidTag", "MATCH_MODE", "QUIRK_COMPONENT_CODE_ID", "QUIRK_CODE_ID", NULL
 253         }
 254     },
 255     {
 256         TAG_TYPE_WORD | 0x800, 0x800, __LINE__, WINVER_ANY, WINVER_ANY,
 257         {
 258             "InvalidTag", "TAG", "INDEX_TAG", "INDEX_KEY", NULL
 259         }
 260     },
 261
 262     {
 263         TAG_TYPE_DWORD, 0x800, __LINE__, WINVER_ANY, WINVER_WINXP,
 264         {
 265             "InvalidTag", "SIZE", "OFFSET", "CHECKSUM", "SHIM_TAGID", "PATCH_TAGID", "MODULE_TYPE", "VERFILEDATEHI",
 266             "VERFILEDATELO", "VERFILEOS", "VERFILETYPE", "PE_CHECKSUM", "PREVOSMAJORVERSION", "PREVOSMINORVERSION", "PREVOSPLATFORMID", "PREVOSBUILDNO",
 267             "PROBLEM_SEVERITY", "APPHELP_LANGID", "VER_LANGUAGE", "InvalidTag", "ENGINE", "HTMLHELPID", "INDEXFLAGS", "FLAGS",
 268             "VALUETYPE", "DATA_DWORD", "LAYER_TAGID", "MSI_TRANSFORM_TAGID", "LINKER_VERSION", "LINK_DATE", "UPTO_LINK_DATE", "OS_SERVICE_PACK",
 269             "FLAG_TAGID", "RUNTIME_PLATFORM", "OS_SKU", NULL
 270         }
 271     },
 272     {
 273         TAG_TYPE_DWORD, 0x800, __LINE__, WINVER_2003, WINVER_2003,
 274         {
 275             "InvalidTag", "SIZE", "OFFSET", "CHECKSUM", "SHIM_TAGID", "PATCH_TAGID", "MODULE_TYPE", "VERFILEDATEHI",
 276             "VERFILEDATELO", "VERFILEOS", "VERFILETYPE", "PE_CHECKSUM", "PREVOSMAJORVERSION", "PREVOSMINORVERSION", "PREVOSPLATFORMID", "PREVOSBUILDNO",
 277             "PROBLEM_SEVERITY", "APPHELP_LANGID", "VER_LANGUAGE", "InvalidTag", "ENGINE", "HTMLHELPID", "INDEXFLAGS", "FLAGS",
 278             "VALUETYPE", "DATA_DWORD", "LAYER_TAGID", "MSI_TRANSFORM_TAGID", "LINKER_VERSION", "LINK_DATE", "UPTO_LINK_DATE", "OS_SERVICE_PACK",
 279             "FLAG_TAGID", "RUNTIME_PLATFORM", "OS_SKU", "OS_PLATFORM", NULL
 280         }
 281     },
 282     {
 283         TAG_TYPE_DWORD, 0x800, __LINE__, WINVER_VISTA, WINVER_VISTA,
 284         {
 285             "InvalidTag", "SIZE", "OFFSET", "CHECKSUM", "SHIM_TAGID", "PATCH_TAGID", "MODULE_TYPE", "VERDATEHI",
 286             "VERDATELO", "VERFILEOS", "VERFILETYPE", "PE_CHECKSUM", "PREVOSMAJORVER", "PREVOSMINORVER", "PREVOSPLATFORMID", "PREVOSBUILDNO",
 287             "PROBLEMSEVERITY", "LANGID", "VER_LANGUAGE", "InvalidTag", "ENGINE", "HTMLHELPID", "INDEX_FLAGS", "FLAGS",
 288             "DATA_VALUETYPE", "DATA_DWORD", "LAYER_TAGID", "MSI_TRANSFORM_TAGID", "LINKER_VERSION", "LINK_DATE", "UPTO_LINK_DATE", "OS_SERVICE_PACK",
 289             "FLAG_TAGID", "RUNTIME_PLATFORM", "OS_SKU", "OS_PLATFORM", "APP_NAME_RC_ID", "VENDOR_NAME_RC_ID", "SUMMARY_MSG_RC_ID", "VISTA_SKU",
 290             NULL
 291         }
 292     },
 293     {
 294         TAG_TYPE_DWORD, 0x800, __LINE__, WINVER_WIN7, WINVER_ANY,
 295         {
 296             "InvalidTag", "SIZE", "OFFSET", "CHECKSUM", "SHIM_TAGID", "PATCH_TAGID", "MODULE_TYPE", "VERDATEHI",
 297             "VERDATELO", "VERFILEOS", "VERFILETYPE", "PE_CHECKSUM", "PREVOSMAJORVER", "PREVOSMINORVER", "PREVOSPLATFORMID", "PREVOSBUILDNO",
 298             "PROBLEMSEVERITY", "LANGID", "VER_LANGUAGE", "InvalidTag", "ENGINE", "HTMLHELPID", "INDEX_FLAGS", "FLAGS",
 299             "DATA_VALUETYPE", "DATA_DWORD", "LAYER_TAGID", "MSI_TRANSFORM_TAGID", "LINKER_VERSION", "LINK_DATE", "UPTO_LINK_DATE", "OS_SERVICE_PACK",
 300             "FLAG_TAGID", "RUNTIME_PLATFORM", "OS_SKU", "OS_PLATFORM", "APP_NAME_RC_ID", "VENDOR_NAME_RC_ID", "SUMMARY_MSG_RC_ID", "VISTA_SKU",
 301             "DESCRIPTION_RC_ID", "PARAMETER1_RC_ID", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag",
 302             "CONTEXT_TAGID", "EXE_WRAPPER", "URL_ID", NULL
 303         }
 304     },
 305     {
 306         TAG_TYPE_DWORD | 0x800, 0x800, __LINE__, WINVER_ANY, WINVER_ANY,
 307         {
 308             "InvalidTag", "TAGID", NULL
 309         }
 310     },
 311
 312     {
 313         TAG_TYPE_QWORD, 0x1000, __LINE__, WINVER_ANY, WINVER_WINXP,
 314         {
 315             "InvalidTag", "TIME", "BIN_FILE_VERSION", "BIN_PRODUCT_VERSION", "MODTIME", "FLAG_MASK_KERNEL", "UPTO_BIN_PRODUCT_VERSION", "DATA_QWORD",
 316             "FLAG_MASK_USER", "FLAGS_NTVDM1", "FLAGS_NTVDM2", "FLAGS_NTVDM3", "FLAG_MASK_SHELL", "UPTO_BIN_FILE_VERSION", NULL
 317         }
 318     },
 319     {
 320         TAG_TYPE_QWORD, 0x1000, __LINE__, WINVER_2003, WINVER_2003,
 321         {
 322             "InvalidTag", "TIME", "BIN_FILE_VERSION", "BIN_PRODUCT_VERSION", "MODTIME", "FLAG_MASK_KERNEL", "UPTO_BIN_PRODUCT_VERSION", "DATA_QWORD",
 323             "FLAG_MASK_USER", "FLAGS_NTVDM1", "FLAGS_NTVDM2", "FLAGS_NTVDM3", "FLAG_MASK_SHELL", "UPTO_BIN_FILE_VERSION", "FLAG_MASK_FUSION", "FLAGS_PROCESSPARAM",
 324             NULL
 325         }
 326     },
 327     {
 328         TAG_TYPE_QWORD, 0x1000, __LINE__, WINVER_VISTA, WINVER_ANY,
 329         {
 330             "InvalidTag", "TIME", "BIN_FILE_VERSION", "BIN_PRODUCT_VERSION", "MODTIME", "FLAG_MASK_KERNEL", "UPTO_BIN_PRODUCT_VERSION", "DATA_QWORD",
 331             "FLAG_MASK_USER", "FLAGS_NTVDM1", "FLAGS_NTVDM2", "FLAGS_NTVDM3", "FLAG_MASK_SHELL", "UPTO_BIN_FILE_VERSION", "FLAG_MASK_FUSION", "FLAG_PROCESSPARAM",
 332             "FLAG_LUA", "FLAG_INSTALL", NULL
 333         }
 334     },
 335
 336     {
 337         TAG_TYPE_STRINGREF, 0x1000, __LINE__, WINVER_ANY, WINVER_2003,
 338         {
 339             "InvalidTag", "NAME", "DESCRIPTION", "MODULE", "API", "VENDOR", "APP_NAME", "InvalidTag",
 340             "COMMAND_LINE", "COMPANY_NAME", "DLLFILE", "WILDCARD_NAME", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag",
 341             "PRODUCT_NAME", "PRODUCT_VERSION", "FILE_DESCRIPTION", "FILE_VERSION", "ORIGINAL_FILENAME", "INTERNAL_NAME", "LEGAL_COPYRIGHT", "S16BIT_DESCRIPTION",
 342             "PROBLEM_DETAILS", "LINK_URL", "LINK_TEXT", "APPHELP_TITLE", "APPHELP_CONTACT", "SXS_MANIFEST", "DATA_STRING", "MSI_TRANSFORM_FILE",
 343             "S16BIT_MODULE_NAME", "LAYER_DISPLAYNAME", "COMPILER_VERSION", "ACTION_TYPE", NULL
 344         }
 345     },
 346     {
 347         TAG_TYPE_STRINGREF, 0x1000, __LINE__, WINVER_VISTA, WINVER_VISTA,
 348         {
 349             "InvalidTag", "NAME", "DESCRIPTION", "MODULE", "API", "VENDOR", "APP_NAME", "InvalidTag",
 350             "COMMAND_LINE", "COMPANY_NAME", "DLLFILE", "WILDCARD_NAME", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag",
 351             "PRODUCT_NAME", "PRODUCT_VERSION", "FILE_DESCRIPTION", "FILE_VERSION", "ORIGINAL_FILENAME", "INTERNAL_NAME", "LEGAL_COPYRIGHT", "16BIT_DESCRIPTION",
 352             "APPHELP_DETAILS", "LINK_URL", "LINK_TEXT", "APPHELP_TITLE", "APPHELP_CONTACT", "SXS_MANIFEST", "DATA_STRING", "MSI_TRANSFORM_FILE",
 353             "16BIT_MODULE_NAME", "LAYER_DISPLAYNAME", "COMPILER_VERSION", "ACTION_TYPE", "EXPORT_NAME", NULL
 354         }
 355     },
 356     {
 357         TAG_TYPE_STRINGREF, 0x1000, __LINE__, WINVER_WIN7, WINVER_ANY,
 358         {
 359             "InvalidTag", "NAME", "DESCRIPTION", "MODULE", "API", "VENDOR", "APP_NAME", "InvalidTag",
 360             "COMMAND_LINE", "COMPANY_NAME", "DLLFILE", "WILDCARD_NAME", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag",
 361             "PRODUCT_NAME", "PRODUCT_VERSION", "FILE_DESCRIPTION", "FILE_VERSION", "ORIGINAL_FILENAME", "INTERNAL_NAME", "LEGAL_COPYRIGHT", "16BIT_DESCRIPTION",
 362             "APPHELP_DETAILS", "LINK_URL", "LINK_TEXT", "APPHELP_TITLE", "APPHELP_CONTACT", "SXS_MANIFEST", "DATA_STRING", "MSI_TRANSFORM_FILE",
 363             "16BIT_MODULE_NAME", "LAYER_DISPLAYNAME", "COMPILER_VERSION", "ACTION_TYPE", "EXPORT_NAME", "URL", NULL
 364         }
 365     },
 366
 367     {
 368         TAG_TYPE_LIST, 0x800, __LINE__, WINVER_ANY, WINVER_2003,
 369         {
 370             "InvalidTag", "DATABASE", "LIBRARY", "INEXCLUDE", "SHIM", "PATCH", "APP", "EXE",
 371             "MATCHING_FILE", "SHIM_REF", "PATCH_REF", "LAYER", "FILE", "APPHELP", "LINK", "DATA",
 372             "MSI TRANSFORM", "MSI TRANSFORM REF", "MSI PACKAGE", "FLAG", "MSI CUSTOM ACTION", "FLAG_REF", "ACTION", NULL
 373         }
 374     },
 375     {
 376         TAG_TYPE_LIST, 0x800, __LINE__, WINVER_VISTA, WINVER_VISTA,
 377         {
 378             "InvalidTag", "DATABASE", "LIBRARY", "INEXCLUDE", "SHIM", "PATCH", "APP", "EXE",
 379             "MATCHING_FILE", "SHIM_REF", "PATCH_REF", "LAYER", "FILE", "APPHELP", "LINK", "DATA",
 380             "MSI_TRANSFORM", "MSI_TRANSFORM_REF", "MSI_PACKAGE", "FLAG", "MSI_CUSTOM_ACTION", "FLAG_REF", "ACTION", "LOOKUP",
 381             NULL
 382         }
 383     },
 384     {
 385         TAG_TYPE_LIST, 0x800, __LINE__, WINVER_WIN7, WINVER_ANY,
 386         {
 387             "InvalidTag", "DATABASE", "LIBRARY", "INEXCLUDE", "SHIM", "PATCH", "APP", "EXE",
 388             "MATCHING_FILE", "SHIM_REF", "PATCH_REF", "LAYER", "FILE", "APPHELP", "LINK", "DATA",
 389             "MSI_TRANSFORM", "MSI_TRANSFORM_REF", "MSI_PACKAGE", "FLAG", "MSI_CUSTOM_ACTION", "FLAG_REF", "ACTION", "LOOKUP",
 390             "CONTEXT", "CONTEXT_REF", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag",
 391             "SPC", NULL
 392         }
 393     },
 394     {
 395         TAG_TYPE_LIST | 0x800, 0x800, __LINE__, WINVER_ANY, WINVER_ANY,
 396         {
 397             "InvalidTag", "STRINGTABLE", "INDEXES", "INDEX", NULL
 398         }
 399     },
 400
 401     {
 402         TAG_TYPE_STRING, 0x800, __LINE__, WINVER_ANY, WINVER_ANY,
 403         {
 404             "InvalidTag", NULL
 405         }
 406     },
 407     {
 408         TAG_TYPE_STRING | 0x800, 0x800, __LINE__, WINVER_ANY, WINVER_2003,
 409         {
 410             "InvalidTag", "STRTAB_ITEM", NULL
 411         }
 412     },
 413     {
 414         TAG_TYPE_STRING | 0x800, 0x800, __LINE__, WINVER_VISTA, WINVER_ANY,
 415         {
 416             "InvalidTag", "STRINGTABLE_ITEM", NULL
 417         }
 418     },
 419
 420
 421     {
 422         TAG_TYPE_BINARY, 0x800, __LINE__, WINVER_ANY, WINVER_2003,
 423         {
 424             "InvalidTag", "InvalidTag", "PATCH_BITS", "FILE_BITS", "EXE_ID(GUID)", "DATA_BITS", "MSI_PACKAGE_ID(GUID)", "DATABASE_ID(GUID)",
 425             NULL
 426         }
 427     },
 428     {
 429         TAG_TYPE_BINARY, 0x800, __LINE__, WINVER_VISTA, WINVER_VISTA,
 430         {
 431             "InvalidTag", "InvalidTag", "PATCH_BITS", "FILE_BITS", "EXE_ID", "DATA_BITS", "MSI_PACKAGE_ID", "DATABASE_ID",
 432             NULL
 433         }
 434     },
 435     {
 436         TAG_TYPE_BINARY, 0x800, __LINE__, WINVER_WIN7, WINVER_ANY,
 437         {
 438             "InvalidTag", "InvalidTag", "PATCH_BITS", "FILE_BITS", "EXE_ID", "DATA_BITS", "MSI_PACKAGE_ID", "DATABASE_ID",
 439             "CONTEXT_PLATFORM_ID", "CONTEXT_BRANCH_ID", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag", "InvalidTag",
 440             "FIX_ID", "APP_ID", NULL
 441         }
 442     },
 443     {
 444         TAG_TYPE_BINARY | 0x800, 0x800, __LINE__, WINVER_ANY, WINVER_ANY,
 445         {
 446             "InvalidTag", "INDEX_BITS", NULL
 447         }
 448     },
 449
 450     { 0, 0, 0, 0, 0, { NULL } }
 451 };
 452
 453
 454 static void test_SdbTagToStringAllTags(void)
 455 {
 456     int n;
 457     for (n = 0; data[n].base; ++n)
 458     {
 459         if ((data[n].min_ver == WINVER_ANY || g_WinVersion >= data[n].min_ver) &&
 460             (data[n].max_ver == WINVER_ANY || g_WinVersion <= data[n].max_ver))
 461         {
 462             test_tag(data[n].base, data[n].tags, data[n].upper_limit, data[n].line);
 463         }
 464     }
 465 }
 466
 467 static void test_GuidFunctions(void)
 468 {
 469     GUID guid;
 470     ok(pSdbIsNullGUID(&GUID_NULL), "expected GUID_NULL to be recognized as NULL GUID\n");
 471     ok(pSdbIsNullGUID(NULL), "expected NULL to be recognized as NULL GUID\n");
 472     ok(pSdbIsNullGUID(&test_UserAssist) == 0, "expected a set GUID not to be recognized as NULL GUID\n");
 473
 474     memset(&guid, 0, sizeof(guid));
 475     ok(pSdbGetStandardDatabaseGUID(0, &guid) == 0,"Expected SdbGetStandardDatabaseGUID to fail\n");
 476     ok(IsEqualGUID(&GUID_NULL, &guid), "Expected guid not to be changed\n");
 477
 478     ok(pSdbGetStandardDatabaseGUID(0x80020000, NULL),"Expected SdbGetStandardDatabaseGUID to succeed\n");
 479
 480     memset(&guid, 0, sizeof(guid));
 481     ok(pSdbGetStandardDatabaseGUID(0x80020000, &guid),"Expected SdbGetStandardDatabaseGUID to succeed\n");
 482     ok(IsEqualGUID(&GUID_DATABASE_MSI, &guid), "Expected guid to equal GUID_DATABASE_MSI, was: %s\n", wine_dbgstr_guid(&guid));
 483
 484     memset(&guid, 0, sizeof(guid));
 485     ok(pSdbGetStandardDatabaseGUID(0x80030000, &guid),"Expected SdbGetStandardDatabaseGUID to succeed\n");
 486     ok(IsEqualGUID(&GUID_DATABASE_SHIM, &guid), "Expected guid to equal GUID_DATABASE_SHIM, was: %s\n", wine_dbgstr_guid(&guid));
 487
 488     memset(&guid, 0, sizeof(guid));
 489     ok(pSdbGetStandardDatabaseGUID(0x80040000, &guid),"Expected SdbGetStandardDatabaseGUID to succeed\n");
 490     ok(IsEqualGUID(&GUID_DATABASE_DRIVERS, &guid), "Expected guid to equal GUID_DATABASE_DRIVERS, was: %s\n", wine_dbgstr_guid(&guid));
 491 }
 492
 493 static void expect_tag_skip_imp(PATTRINFO pattr, DWORD num)
 494 {
 495     PATTRINFO p = &pattr[num];
 496     winetest_ok(p->type == TAG_NULL, "expected entry #%d to be TAG_NULL, was %x\n", num, p->type);
 497     winetest_ok(p->flags == ATTRIBUTE_FAILED, "expected entry #%d to be failed, was %d\n", num, p->flags);
 498     winetest_ok(p->qwattr == 0, "expected entry #%d to be 0, was 0x%I64x\n", num, p->qwattr);
 499 }
 500 static void expect_tag_empty_imp(PATTRINFO pattr, DWORD num)
 501 {
 502     PATTRINFO p = &pattr[num];
 503     winetest_ok(p->type == TAG_NULL, "expected entry #%d to be TAG_NULL, was %x\n", num, p->type);
 504     winetest_ok(p->flags == 0, "expected entry #%d to be 0, was %d\n", num, p->flags);
 505     winetest_ok(p->qwattr == 0, "expected entry #%d to be 0, was 0x%I64x\n", num, p->qwattr);
 506 }
 507
 508 static void expect_tag_dword_imp(PATTRINFO pattr, DWORD num, TAG tag, DWORD value)
 509 {
 510     PATTRINFO p = &pattr[num];
 511     winetest_ok(p->type == tag, "expected entry #%d to be %x, was %x\n", num, tag, p->type);
 512     winetest_ok(p->flags == ATTRIBUTE_AVAILABLE, "expected entry #%d to be available, was %d\n", num, p->flags);
 513     winetest_ok(p->dwattr == value, "expected entry #%d to be 0x%x, was 0x%x\n", num, value, p->dwattr);
 514 }
 515
 516 static void expect_tag_qword_imp(PATTRINFO pattr, DWORD num, TAG tag, QWORD value)
 517 {
 518     PATTRINFO p = &pattr[num];
 519     winetest_ok(p->type == tag, "expected entry #%d to be %x, was %x\n", num, tag, p->type);
 520     winetest_ok(p->flags == ATTRIBUTE_AVAILABLE, "expected entry #%d to be available, was %d\n", num, p->flags);
 521     winetest_ok(p->qwattr == value, "expected entry #%d to be 0x%I64x, was 0x%I64x\n", num, value, p->qwattr);
 522 }
 523
 524 static void expect_tag_str_imp(PATTRINFO pattr, DWORD num, TAG tag, const WCHAR* value)
 525 {
 526     PATTRINFO p = &pattr[num];
 527     winetest_ok(p->type == tag, "expected entry #%d to be %x, was %x\n", num, tag, p->type);
 528     winetest_ok(p->flags == ATTRIBUTE_AVAILABLE, "expected entry #%d to be available, was %d\n", num, p->flags);
 529     winetest_ok(p->lpattr && wcscmp(p->lpattr, value) == 0, "expected entry #%d to be %s, was %s\n", num, wine_dbgstr_w(value), wine_dbgstr_w(p->lpattr));
 530 }
 531
 532 #define expect_tag_skip     (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_tag_skip_imp
 533 #define expect_tag_empty    (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_tag_empty_imp
 534 #define expect_tag_dword    (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_tag_dword_imp
 535 #define expect_tag_qword    (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_tag_qword_imp
 536 #define expect_tag_str      (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_tag_str_imp
 537 #define expect_tag_skip_range(ptr, from, to) \
 538     do { \
 539         int n = (from), n_end = (to); \
 540         winetest_set_location(__FILE__, __LINE__); \
 541         for ( ; n < n_end; ++n) \
 542             expect_tag_skip_imp((ptr), n); \
 543     } while (0)
 544 #define test_crc            (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : test_crc_imp
 545 #define test_crc2           (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : test_crc2_imp
 546
 547 void test_onefile(WCHAR* filename)
 548 {
 549     PATTRINFO pattrinfo;
 550     DWORD num;
 551
 552     if (!pSdbFreeFileAttributes)
 553     {
 554         hdll = LoadLibraryA("apphelp.dll");
 555         pSdbTagToString = (void *)GetProcAddress(hdll, "SdbTagToString");
 556         pSdbGetFileAttributes = (void *)GetProcAddress(hdll, "SdbGetFileAttributes");
 557         pSdbFreeFileAttributes = (void *)GetProcAddress(hdll, "SdbFreeFileAttributes");
 558     }
 559
 560     if (pSdbGetFileAttributes(filename, &pattrinfo, &num))
 561     {
 562         if (pattrinfo[16].flags == ATTRIBUTE_AVAILABLE)
 563         {
 564             if (pattrinfo[16].type != TAG_MODULE_TYPE)//SdbpSetAttrFail(&attr_info[16]); /* TAG_MODULE_TYPE (1: WIN16?) (3: WIN32?) (WIN64?), Win32VersionValue? */)
 565                 printf("FAIL TAG_MODULE_TYPE (%S)\n", filename);
 566             if (pattrinfo[16].dwattr != 3 && pattrinfo[16].dwattr != 2)
 567                 printf("TAG_MODULE_TYPE(%S): %d\n", filename, pattrinfo[16].dwattr);    // C:\Program Files (x86)\Windows Kits\8.1\Lib\win7\stub512.com
 568             if (pattrinfo[16].dwattr == 2)
 569             {
 570                 printf("TAG_MODULE_TYPE(%S): %d, %d\n", filename, pattrinfo[16].dwattr, pattrinfo[0].dwattr);
 571             }
 572         }
 573
 574         if (pattrinfo[27].flags == ATTRIBUTE_AVAILABLE)
 575         {
 576             if (pattrinfo[27].type != TAG_EXE_WRAPPER)
 577                 printf("FAIL TAG_EXE_WRAPPER (%S)\n", filename);
 578             if (pattrinfo[27].dwattr != 0)
 579                 printf("TAG_EXE_WRAPPER(%S): %d\n", filename, pattrinfo[27].dwattr);
 580         }
 581
 582         pSdbFreeFileAttributes(pattrinfo);
 583     }
 584 }
 585
 586 static void test_crc_imp(size_t len, DWORD expected)
 587 {
 588     static const WCHAR path[] = {'t','e','s','t','x','x','.','e','x','e',0};
 589     static char crc_test[] = {4, 4, 4, 4, 1, 1, 1, 1, 4, 4, 4, 4, 2, 2, 2, 2};
 590
 591     PATTRINFO pattrinfo = (PATTRINFO)0xdead;
 592     DWORD num = 333;
 593     BOOL ret;
 594
 595     test_create_file_imp(L"testxx.exe", crc_test, len);
 596     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 597     winetest_ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 598     winetest_ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 599     winetest_ok(num == 28, "expected 28 items, got %d.\n", num);
 600
 601     if (num == 28 && ret)
 602     {
 603         expect_tag_dword_imp(pattrinfo, 1, TAG_CHECKSUM, expected);
 604     }
 605     if (ret)
 606         pSdbFreeFileAttributes(pattrinfo);
 607 }
 608
 609 static void test_crc2_imp(size_t len, int fill, DWORD expected)
 610 {
 611     static const WCHAR path[] = {'t','e','s','t','x','x','.','e','x','e',0};
 612
 613     PATTRINFO pattrinfo = (PATTRINFO)0xdead;
 614     DWORD num = 333;
 615     BOOL ret;
 616     size_t n;
 617     char* crc_test = malloc(len);
 618     for (n = 0; n < len; ++n)
 619         crc_test[n] = (char)(fill ? fill : n);
 620
 621     test_create_file_imp(L"testxx.exe", crc_test, len);
 622     free(crc_test);
 623     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 624     winetest_ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 625     winetest_ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 626     winetest_ok(num == 28, "expected 28 items, got %d.\n", num);
 627
 628     if (num == 28 && ret)
 629     {
 630         expect_tag_dword_imp(pattrinfo, 0, TAG_SIZE, len);
 631         expect_tag_dword_imp(pattrinfo, 1, TAG_CHECKSUM, expected);
 632     }
 633     if (ret)
 634         pSdbFreeFileAttributes(pattrinfo);
 635 }
 636
 637
 638
 639 static void test_ApplicationAttributes(void)
 640 {
 641     static const WCHAR path[] = {'t','e','s','t','x','x','.','e','x','e',0};
 642     static const WCHAR PRODUCT_VERSION[] = {'1','.','0','.','0','.','1',0};
 643     static const WCHAR FILE_DESCRIPTION[] = {'F','i','l','e','D','e','s','c','r','i','p','t','i','o','n',0};
 644     static const WCHAR COMPANY_NAME[] = {'C','o','m','p','a','n','y','N','a','m','e',0};
 645     static const WCHAR PRODUCT_NAME[] = {'P','r','o','d','u','c','t','N','a','m','e',0};
 646     static const WCHAR FILE_VERSION[] = {'1','.','0','.','0','.','0',0};
 647     static const WCHAR ORIGINAL_FILENAME[] = {'O','r','i','g','i','n','a','l','F','i','l','e','n','a','m','e',0};
 648     static const WCHAR INTERNAL_NAME[] = {'I','n','t','e','r','n','a','l','N','a','m','e',0};
 649     static const WCHAR LEGAL_COPYRIGHT[] = {'L','e','g','a','l','C','o','p','y','r','i','g','h','t',0};
 650     static const WCHAR EXPORT_NAME[] = {'T','e','S','t','2','.','e','x','e',0};
 651     static const WCHAR OS2_DESCRIPTION[] = {'M','O','D',' ','D','E','S','C','R','I','P','T','I','O','N',' ','H','E','R','E',0};
 652     static const WCHAR OS2_EXPORT_NAME[] = {'T','E','S','T','M','O','D','.','h','X','x',0};
 653     static const WCHAR OS2_DESCRIPTION_broken[] = {'Z',0};
 654     static const WCHAR OS2_EXPORT_NAME_broken[] = {'E',0};
 655
 656     PATTRINFO pattrinfo = (PATTRINFO)0xdead;
 657     DWORD num = 333;
 658     BOOL ret;
 659
 660     /* ensure the file is not there. */
 661     DeleteFileA("testxx.exe");
 662     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 663     ok(ret == FALSE, "expected SdbGetFileAttributes to fail.\n");
 664     ok(pattrinfo == (PATTRINFO)0xdead, "expected the pointer not to change.\n");
 665     ok(num == 333, "expected the number of items not to change.\n");
 666     if (ret)
 667         pSdbFreeFileAttributes(pattrinfo);
 668
 669     /* Test a file with as much features as possible */
 670     test_create_exe(L"testxx.exe", 0);
 671
 672     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 673     ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 674     ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 675     ok(num == 28, "expected 28 items, got %d.\n", num);
 676
 677     if (num == 28 && ret)
 678     {
 679         expect_tag_dword(pattrinfo, 0, TAG_SIZE, 0x800);
 680         expect_tag_dword(pattrinfo, 1, TAG_CHECKSUM, 0x178bd629);
 681         expect_tag_qword(pattrinfo, 2, TAG_BIN_FILE_VERSION, 0x1000000000000ull);
 682         expect_tag_qword(pattrinfo, 3, TAG_BIN_PRODUCT_VERSION, 0x1000000000001ull);
 683         expect_tag_str(pattrinfo, 4, TAG_PRODUCT_VERSION, PRODUCT_VERSION);
 684         expect_tag_str(pattrinfo, 5, TAG_FILE_DESCRIPTION, FILE_DESCRIPTION);
 685         expect_tag_str(pattrinfo, 6, TAG_COMPANY_NAME, COMPANY_NAME);
 686         expect_tag_str(pattrinfo, 7, TAG_PRODUCT_NAME, PRODUCT_NAME);
 687         expect_tag_str(pattrinfo, 8, TAG_FILE_VERSION, FILE_VERSION);
 688         expect_tag_str(pattrinfo, 9, TAG_ORIGINAL_FILENAME, ORIGINAL_FILENAME);
 689         expect_tag_str(pattrinfo, 10, TAG_INTERNAL_NAME, INTERNAL_NAME);
 690         expect_tag_str(pattrinfo, 11, TAG_LEGAL_COPYRIGHT, LEGAL_COPYRIGHT);
 691         expect_tag_dword(pattrinfo, 12, TAG_VERDATEHI, 0x1d1a019);
 692         expect_tag_dword(pattrinfo, 13, TAG_VERDATELO, 0xac754c50);
 693         expect_tag_dword(pattrinfo, 14, TAG_VERFILEOS, VOS__WINDOWS32);
 694         expect_tag_dword(pattrinfo, 15, TAG_VERFILETYPE, VFT_APP);
 695         expect_tag_dword(pattrinfo, 16, TAG_MODULE_TYPE, 0x3); /* Win32 */
 696         expect_tag_dword(pattrinfo, 17, TAG_PE_CHECKSUM, 0xBAAD);
 697         expect_tag_dword(pattrinfo, 18, TAG_LINKER_VERSION, 0x40002);
 698         expect_tag_skip(pattrinfo, 19); /* TAG_16BIT_DESCRIPTION */
 699         expect_tag_skip(pattrinfo, 20); /* TAG_16BIT_MODULE_NAME */
 700         expect_tag_qword(pattrinfo, 21, TAG_UPTO_BIN_FILE_VERSION, 0x1000000000000ull);
 701         expect_tag_qword(pattrinfo, 22, TAG_UPTO_BIN_PRODUCT_VERSION, 0x1000000000001ull);
 702         expect_tag_dword(pattrinfo, 23, TAG_LINK_DATE, 0x12345);
 703         expect_tag_dword(pattrinfo, 24, TAG_UPTO_LINK_DATE, 0x12345);
 704         expect_tag_str(pattrinfo, 25, TAG_EXPORT_NAME, EXPORT_NAME);
 705         expect_tag_dword(pattrinfo, 26, TAG_VER_LANGUAGE, 0xffff);
 706         expect_tag_dword(pattrinfo, 27, TAG_EXE_WRAPPER, 0x0);
 707     }
 708     if (ret)
 709         pSdbFreeFileAttributes(pattrinfo);
 710
 711
 712     /* Disable resource and exports */
 713     test_create_exe(L"testxx.exe", 1);
 714
 715     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 716     ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 717     ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 718     ok(num == 28, "expected 28 items, got %d.\n", num);
 719
 720     if (num == 28 && ret)
 721     {
 722         expect_tag_dword(pattrinfo, 0, TAG_SIZE, 0x800);
 723         expect_tag_dword(pattrinfo, 1, TAG_CHECKSUM, 0xea7caffd);
 724         expect_tag_skip_range(pattrinfo, 2, 16);
 725         expect_tag_dword(pattrinfo, 16, TAG_MODULE_TYPE, 0x3); /* Win32 */
 726         expect_tag_dword(pattrinfo, 17, TAG_PE_CHECKSUM, 0xBAAD);
 727         expect_tag_dword(pattrinfo, 18, TAG_LINKER_VERSION, 0x40002);
 728         expect_tag_skip_range(pattrinfo, 19, 23);
 729         expect_tag_dword(pattrinfo, 23, TAG_LINK_DATE, 0x12345);
 730         expect_tag_dword(pattrinfo, 24, TAG_UPTO_LINK_DATE, 0x12345);
 731         expect_tag_skip(pattrinfo, 25); /* TAG_EXPORT_NAME */
 732         expect_tag_empty(pattrinfo, 26); /* TAG_VER_LANGUAGE */
 733         expect_tag_dword(pattrinfo, 27, TAG_EXE_WRAPPER, 0x0);
 734     }
 735     if (ret)
 736         pSdbFreeFileAttributes(pattrinfo);
 737
 738     /* A file with just 'MZ' */
 739     test_create_file(L"testxx.exe", "MZ", 2);
 740
 741     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 742     ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 743     ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 744     ok(num == 28, "expected 28 items, got %d.\n", num);
 745
 746     if (num == 28 && ret)
 747     {
 748         expect_tag_dword(pattrinfo, 0, TAG_SIZE, 0x2);
 749         expect_tag_dword(pattrinfo, 1, TAG_CHECKSUM, 0);
 750         expect_tag_skip_range(pattrinfo, 2, 16);
 751         expect_tag_dword(pattrinfo, 16, TAG_MODULE_TYPE, 0x1);
 752         expect_tag_skip_range(pattrinfo, 17, 26);
 753         expect_tag_empty(pattrinfo, 26); /* TAG_VER_LANGUAGE */
 754         expect_tag_skip(pattrinfo, 27); /* TAG_EXE_WRAPPER */
 755     }
 756     if (ret)
 757         pSdbFreeFileAttributes(pattrinfo);
 758
 759     /* Empty file */
 760     test_create_file(L"testxx.exe", NULL, 0);
 761
 762     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 763     ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 764     ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 765     ok(num == 28, "expected 28 items, got %d.\n", num);
 766
 767     if (num == 28 && ret)
 768     {
 769         expect_tag_dword(pattrinfo, 0, TAG_SIZE, 0);
 770         expect_tag_skip_range(pattrinfo, 1, 26);
 771         expect_tag_empty(pattrinfo, 26); /* TAG_VER_LANGUAGE */
 772         expect_tag_skip(pattrinfo, 27); /* TAG_EXE_WRAPPER */
 773     }
 774     if (ret)
 775         pSdbFreeFileAttributes(pattrinfo);
 776
 777     /* minimal NE executable */
 778     test_create_ne(L"testxx.exe", 0);
 779
 780     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 781     ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 782     ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 783     ok(num == 28, "expected 28 items, got %d.\n", num);
 784
 785     if (num == 28 && ret)
 786     {
 787         expect_tag_dword(pattrinfo, 0, TAG_SIZE, 0xa8);
 788         expect_tag_dword(pattrinfo, 1, TAG_CHECKSUM, 0xf2abe4e9);
 789         expect_tag_skip_range(pattrinfo, 2, 16);
 790         expect_tag_dword(pattrinfo, 16, TAG_MODULE_TYPE, 0x2);
 791         expect_tag_skip(pattrinfo, 17); /* TAG_PE_CHECKSUM */
 792         expect_tag_skip(pattrinfo, 18); /* TAG_LINKER_VERSION */
 793         expect_tag_str(pattrinfo, 19, TAG_16BIT_DESCRIPTION, OS2_DESCRIPTION);
 794         expect_tag_str(pattrinfo, 20, TAG_16BIT_MODULE_NAME, OS2_EXPORT_NAME);
 795         expect_tag_skip_range(pattrinfo, 21, 26);
 796         expect_tag_empty(pattrinfo, 26); /* TAG_VER_LANGUAGE */
 797         expect_tag_skip(pattrinfo, 27); /* TAG_EXE_WRAPPER */
 798     }
 799     if (ret)
 800         pSdbFreeFileAttributes(pattrinfo);
 801
 802     /* NE executable with description / module name pointers zero, to show they are always used */
 803     test_create_ne(L"testxx.exe", 1);
 804
 805     ret = pSdbGetFileAttributes(path, &pattrinfo, &num);
 806     ok(ret != FALSE, "expected SdbGetFileAttributes to succeed.\n");
 807     ok(pattrinfo != (PATTRINFO)0xdead, "expected a valid pointer.\n");
 808     ok(num == 28, "expected 28 items, got %d.\n", num);
 809
 810     if (num == 28 && ret)
 811     {
 812         expect_tag_dword(pattrinfo, 0, TAG_SIZE, 0xa8);
 813         expect_tag_dword(pattrinfo, 1, TAG_CHECKSUM, 0xddcbe4c9);
 814         expect_tag_skip_range(pattrinfo, 2, 16);
 815         expect_tag_dword(pattrinfo, 16, TAG_MODULE_TYPE, 0x2);
 816         expect_tag_skip(pattrinfo, 17); /* TAG_PE_CHECKSUM */
 817         expect_tag_skip(pattrinfo, 18); /* TAG_LINKER_VERSION */
 818         expect_tag_str(pattrinfo, 19, TAG_16BIT_DESCRIPTION, OS2_DESCRIPTION_broken);   /* the 'Z' from 'MZ' */
 819         expect_tag_str(pattrinfo, 20, TAG_16BIT_MODULE_NAME, OS2_EXPORT_NAME_broken);   /* the 'E' from 'NE' */
 820         expect_tag_skip_range(pattrinfo, 21, 26);
 821         expect_tag_empty(pattrinfo, 26); /* TAG_VER_LANGUAGE */
 822         expect_tag_skip(pattrinfo, 27); /* TAG_EXE_WRAPPER */
 823     }
 824     if (ret)
 825         pSdbFreeFileAttributes(pattrinfo);
 826
 827     test_crc(1, 0);
 828     test_crc(2, 0);
 829     test_crc(3, 0);
 830     test_crc(4, 0x2020202);
 831     test_crc(5, 0x2020202);
 832     test_crc(6, 0x2020202);
 833     test_crc(7, 0x2020202);
 834     test_crc(8, 0x81818181);
 835     test_crc(9, 0x81818181);
 836     test_crc(10, 0x81818181);
 837     test_crc(11, 0x81818181);
 838     test_crc(12, 0xc2c2c2c2);
 839     test_crc(16, 0x62626262);
 840
 841     /* This seems to be the cutoff point */
 842     test_crc2(0xffc, 4, 0xfbfbfcfc);
 843     test_crc2(0xffc, 8, 0x7070717);
 844     test_crc2(0xffc, 0xcc, 0xc8eba002);
 845     test_crc2(0xffc, 0, 0x4622028d);
 846
 847     test_crc2(0x1000, 4, 0x80);
 848     test_crc2(0x1000, 8, 0x8787878f);
 849     test_crc2(0x1000, 0xcc, 0x4adc3667);
 850     test_crc2(0x1000, 0, 0xa3108044);
 851
 852     /* Here is another cutoff point */
 853     test_crc2(0x11fc, 4, 0x80);
 854     test_crc2(0x11fc, 8, 0x8787878f);
 855     test_crc2(0x11fc, 0xcc, 0x4adc3667);
 856     test_crc2(0x11fc, 0, 0xf03e0800);
 857
 858     test_crc2(0x1200, 4, 0x80);
 859     test_crc2(0x1200, 8, 0x8787878f);
 860     test_crc2(0x1200, 0xcc, 0x4adc3667);
 861     test_crc2(0x1200, 0, 0xa3108044);
 862
 863     /* After that, it stays the same for all sizes */
 864     test_crc2(0xf000, 4, 0x80);
 865     test_crc2(0xf000, 8, 0x8787878f);
 866     test_crc2(0xf000, 0xcc, 0x4adc3667);
 867     test_crc2(0xf000, 0, 0xa3108044);
 868
 869
 870     DeleteFileA("testxx.exe");
 871 }
 872
 873 /* Showing that SdbGetAppPatchDir returns HRESULT */
 874 static void test_SdbGetAppPatchDir(void)
 875 {
 876     WCHAR Buffer[MAX_PATH];
 877     HRESULT hr, expect_hr;
 878     int n;
 879
 880
 881     _SEH2_TRY
 882     {
 883         hr = pSdbGetAppPatchDir(NULL, NULL, 0);
 884         ok_hex(hr, S_FALSE);
 885     }
 886     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 887     {
 888         /* Some versions accept it, some don't */
 889         trace("SdbGetAppPatchDir did not handle a NULL pointer very gracefully.\n");
 890     }
 891     _SEH2_END;
 892
 893
 894
 895     memset(Buffer, 0xbb, sizeof(Buffer));
 896     hr = pSdbGetAppPatchDir(NULL, Buffer, 0);
 897     if (g_WinVersion < WINVER_WIN7)
 898         expect_hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
 899     else if (g_WinVersion < WINVER_WIN10)
 900         expect_hr = S_OK;
 901     else
 902         expect_hr = S_FALSE;
 903     ok_hex(hr, expect_hr);
 904
 905     if (g_WinVersion < WINVER_WIN7)
 906         expect_hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 907     else if (g_WinVersion < WINVER_WIN10)
 908         expect_hr = S_OK;
 909     else
 910         expect_hr = TRUE;
 911
 912     memset(Buffer, 0xbb, sizeof(Buffer));
 913     hr = pSdbGetAppPatchDir(NULL, Buffer, 1);
 914     ok_hex(hr, expect_hr);
 915
 916
 917     for (n = 2; n < _countof(Buffer) - 1; ++n)
 918     {
 919         memset(Buffer, 0xbb, sizeof(Buffer));
 920         hr = pSdbGetAppPatchDir(NULL, Buffer, n);
 921         ok(Buffer[n] == 0xbbbb, "Expected SdbGetAppPatchDir to leave WCHAR at %d untouched, was: %d\n",
 922            n, Buffer[n]);
 923         ok(hr == S_OK || hr == expect_hr, "Expected S_OK or 0x%x, was: 0x%x (at %d)\n", expect_hr, hr, n);
 924     }
 925 }
 926 START_TEST(apphelp)
 927 {
 928     //SetEnvironmentVariable("SHIM_DEBUG_LEVEL", "4");
 929     //SetEnvironmentVariable("DEBUGCHANNEL", "+apphelp");
 930     silence_debug_output();
 931
 932     hdll = LoadLibraryA("apphelp.dll");
 933     g_WinVersion = get_module_version(hdll);
 934     trace("Detected apphelp.dll version: 0x%x\n", g_WinVersion);
 935
 936 #define RESOLVE(fnc)    do { p##fnc = (void *) GetProcAddress(hdll, #fnc); ok(!!p##fnc, #fnc " not found.\n"); } while (0)
 937     RESOLVE(ApphelpCheckShellObject);
 938     RESOLVE(SdbTagToString);
 939     RESOLVE(SdbGUIDToString);
 940     RESOLVE(SdbIsNullGUID);
 941     RESOLVE(SdbGetStandardDatabaseGUID);
 942     RESOLVE(SdbGetFileAttributes);
 943     RESOLVE(SdbFreeFileAttributes);
 944     RESOLVE(SdbGetAppPatchDir);
 945 #undef RESOLVE
 946
 947     test_ApphelpCheckShellObject();
 948     test_GuidFunctions();
 949     test_ApplicationAttributes();
 950     test_SdbTagToString();
 951     test_SdbTagToStringAllTags();
 952     if (pSdbGetAppPatchDir)
 953         test_SdbGetAppPatchDir();
 954 }