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