ad3f053a6d14e66101842ea44b7e536023efdb4c
[reactos.git] / rostests / apitests / apphelp / db.cpp
1 /*
2 * Copyright 2012 Detlef Riekenberg
3 * Copyright 2013 Mislav Blažević
4 * Copyright 2015-2017 Mark Jansen
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21
22 #include <ntstatus.h>
23 #define WIN32_NO_STATUS
24 #include <windows.h>
25 #include <shlwapi.h>
26 #include <winnt.h>
27 #ifdef __REACTOS__
28 #include <ntndk.h>
29 #else
30 #include <winternl.h>
31 #endif
32
33 #include <winerror.h>
34 #include <stdio.h>
35 #include <initguid.h>
36
37 #include "wine/test.h"
38
39 #include "apphelp_apitest.h"
40
41
42 #define DOS_PATH 0
43 #define HID_DATABASE_FULLPATH 2
44
45 #define SDB_DATABASE_MAIN_SHIM 0x80030000
46
47
48 #define TAGID_NULL 0x0
49 #define TAGID_ROOT 0x0
50 #define _TAGID_ROOT 12
51
52
53 #define TAG_TYPE_MASK 0xF000
54
55 #define TAG_TYPE_NULL 0x1000
56 #define TAG_TYPE_BYTE 0x2000
57 #define TAG_TYPE_WORD 0x3000
58 #define TAG_TYPE_DWORD 0x4000
59 #define TAG_TYPE_QWORD 0x5000
60 #define TAG_TYPE_STRINGREF 0x6000
61 #define TAG_TYPE_LIST 0x7000
62 #define TAG_TYPE_STRING 0x8000
63 #define TAG_TYPE_BINARY 0x9000
64 #define TAG_NULL 0x0
65
66 #define TAG_INCLUDE (0x1 | TAG_TYPE_NULL)
67
68 #define TAG_MATCH_MODE (0x1 | TAG_TYPE_WORD)
69
70 #define TAG_SIZE (0x1 | TAG_TYPE_DWORD)
71 #define TAG_CHECKSUM (0x3 | TAG_TYPE_DWORD)
72 #define TAG_MODULE_TYPE (0x6 | TAG_TYPE_DWORD)
73 #define TAG_VERFILEOS (0x9 | TAG_TYPE_DWORD)
74 #define TAG_VERFILETYPE (0xA | TAG_TYPE_DWORD)
75 #define TAG_PE_CHECKSUM (0xB | TAG_TYPE_DWORD)
76 #define TAG_PROBLEMSEVERITY (0x10 | TAG_TYPE_DWORD)
77 #define TAG_HTMLHELPID (0x15 | TAG_TYPE_DWORD)
78 #define TAG_FLAGS (0x17 | TAG_TYPE_DWORD)
79 #define TAG_LAYER_TAGID (0x1A | TAG_TYPE_DWORD)
80 #define TAG_LINKER_VERSION (0x1C | TAG_TYPE_DWORD)
81 #define TAG_LINK_DATE (0x1D | TAG_TYPE_DWORD)
82 #define TAG_UPTO_LINK_DATE (0x1E | TAG_TYPE_DWORD)
83 #define TAG_APP_NAME_RC_ID (0x24 | TAG_TYPE_DWORD)
84 #define TAG_VENDOR_NAME_RC_ID (0x25 | TAG_TYPE_DWORD)
85 #define TAG_SUMMARY_MSG_RC_ID (0x26 | TAG_TYPE_DWORD)
86 #define TAG_OS_PLATFORM (0x23 | TAG_TYPE_DWORD)
87
88 #define TAG_TIME (0x1 | TAG_TYPE_QWORD)
89 #define TAG_BIN_FILE_VERSION (0x2 | TAG_TYPE_QWORD)
90 #define TAG_BIN_PRODUCT_VERSION (0x3 | TAG_TYPE_QWORD)
91 #define TAG_UPTO_BIN_PRODUCT_VERSION (0x6 | TAG_TYPE_QWORD)
92 #define TAG_UPTO_BIN_FILE_VERSION (0xD | TAG_TYPE_QWORD)
93 #define TAG_FLAG_LUA (0x10 | TAG_TYPE_QWORD)
94
95 #define TAG_DATABASE (0x1 | TAG_TYPE_LIST)
96 #define TAG_INEXCLUD (0x3 | TAG_TYPE_LIST)
97 #define TAG_EXE (0x7 | TAG_TYPE_LIST)
98 #define TAG_MATCHING_FILE (0x8 | TAG_TYPE_LIST)
99 #define TAG_SHIM_REF (0x9| TAG_TYPE_LIST)
100 #define TAG_LAYER (0xB | TAG_TYPE_LIST)
101 #define TAG_APPHELP (0xD | TAG_TYPE_LIST)
102 #define TAG_LINK (0xE | TAG_TYPE_LIST)
103 #define TAG_STRINGTABLE (0x801 | TAG_TYPE_LIST)
104
105 #define TAG_STRINGTABLE_ITEM (0x801 | TAG_TYPE_STRING)
106
107 #define TAG_NAME (0x1 | TAG_TYPE_STRINGREF)
108 #define TAG_MODULE (0x3 | TAG_TYPE_STRINGREF)
109 #define TAG_VENDOR (0x5 | TAG_TYPE_STRINGREF)
110 #define TAG_APP_NAME (0x6 | TAG_TYPE_STRINGREF)
111 #define TAG_COMMAND_LINE (0x8 | TAG_TYPE_STRINGREF)
112 #define TAG_COMPANY_NAME (0x9 | TAG_TYPE_STRINGREF)
113 #define TAG_PRODUCT_NAME (0x10 | TAG_TYPE_STRINGREF)
114 #define TAG_PRODUCT_VERSION (0x11 | TAG_TYPE_STRINGREF)
115 #define TAG_FILE_DESCRIPTION (0x12 | TAG_TYPE_STRINGREF)
116 #define TAG_FILE_VERSION (0x13 | TAG_TYPE_STRINGREF)
117 #define TAG_ORIGINAL_FILENAME (0x14 | TAG_TYPE_STRINGREF)
118 #define TAG_INTERNAL_NAME (0x15 | TAG_TYPE_STRINGREF)
119 #define TAG_LEGAL_COPYRIGHT (0x16 | TAG_TYPE_STRINGREF)
120 #define TAG_APPHELP_DETAILS (0x18 | TAG_TYPE_STRINGREF)
121 #define TAG_LINK_URL (0x19 | TAG_TYPE_STRINGREF)
122 #define TAG_APPHELP_TITLE (0x1B | TAG_TYPE_STRINGREF)
123
124 #define TAG_COMPILER_VERSION (0x22 | TAG_TYPE_STRINGREF)
125
126 #define TAG_GENERAL (0x2 | TAG_TYPE_NULL)
127
128 #define TAG_EXE_ID (0x4 | TAG_TYPE_BINARY)
129 #define TAG_DATA_BITS (0x5 | TAG_TYPE_BINARY)
130 #define TAG_DATABASE_ID (0x7 | TAG_TYPE_BINARY)
131
132
133
134 static HMODULE hdll;
135 static LPCWSTR (WINAPI *pSdbTagToString)(TAG);
136 static PDB (WINAPI *pSdbOpenDatabase)(LPCWSTR, PATH_TYPE);
137 static PDB (WINAPI *pSdbCreateDatabase)(LPCWSTR, PATH_TYPE);
138 static BOOL (WINAPI *pSdbGetDatabaseVersion)(LPCWSTR, PDWORD, PDWORD);
139 static void (WINAPI *pSdbCloseDatabase)(PDB);
140 static void (WINAPI *pSdbCloseDatabaseWrite)(PDB);
141 static TAG (WINAPI *pSdbGetTagFromTagID)(PDB, TAGID);
142 static BOOL (WINAPI *pSdbWriteNULLTag)(PDB, TAG);
143 static BOOL (WINAPI *pSdbWriteWORDTag)(PDB, TAG, WORD);
144 static BOOL (WINAPI *pSdbWriteDWORDTag)(PDB, TAG, DWORD);
145 static BOOL (WINAPI *pSdbWriteQWORDTag)(PDB, TAG, QWORD);
146 static BOOL (WINAPI *pSdbWriteBinaryTagFromFile)(PDB, TAG, LPCWSTR);
147 static BOOL (WINAPI *pSdbWriteStringTag)(PDB, TAG, LPCWSTR);
148 static BOOL (WINAPI *pSdbWriteStringRefTag)(PDB, TAG, TAGID);
149 static TAGID (WINAPI *pSdbBeginWriteListTag)(PDB, TAG);
150 static BOOL (WINAPI *pSdbEndWriteListTag)(PDB, TAGID);
151 static TAGID (WINAPI *pSdbFindFirstTag)(PDB, TAGID, TAG);
152 static TAGID (WINAPI *pSdbFindNextTag)(PDB, TAGID, TAGID);
153 static TAGID (WINAPI *pSdbFindFirstNamedTag)(PDB, TAGID, TAGID, TAGID, LPCWSTR);
154 static WORD (WINAPI *pSdbReadWORDTag)(PDB, TAGID, WORD);
155 static DWORD (WINAPI *pSdbReadDWORDTag)(PDB, TAGID, DWORD);
156 static QWORD (WINAPI *pSdbReadQWORDTag)(PDB, TAGID, QWORD);
157 static BOOL (WINAPI *pSdbReadBinaryTag)(PDB, TAGID, PBYTE, DWORD);
158 static BOOL (WINAPI *pSdbReadStringTag)(PDB, TAGID, LPWSTR, DWORD);
159 static DWORD (WINAPI *pSdbGetTagDataSize)(PDB, TAGID);
160 static PVOID (WINAPI *pSdbGetBinaryTagData)(PDB, TAGID);
161 static LPWSTR (WINAPI *pSdbGetStringTagPtr)(PDB, TAGID);
162 static TAGID (WINAPI *pSdbGetFirstChild)(PDB, TAGID);
163 static TAGID (WINAPI *pSdbGetNextChild)(PDB, TAGID, TAGID);
164 static BOOL (WINAPI *pSdbGetDatabaseID)(PDB, GUID*);
165 static BOOL (WINAPI *pSdbGUIDToString)(CONST GUID *, PCWSTR, SIZE_T);
166 static HSDB (WINAPI *pSdbInitDatabase)(DWORD, LPCWSTR);
167 static void (WINAPI *pSdbReleaseDatabase)(HSDB);
168 static BOOL (WINAPI *pSdbGetMatchingExe)(HSDB hsdb, LPCWSTR path, LPCWSTR module_name, LPCWSTR env, DWORD flags, PSDBQUERYRESULT_VISTA result);
169 static BOOL (WINAPI *pSdbTagRefToTagID)(HSDB hSDB, TAGREF trWhich, PDB *ppdb, TAGID *ptiWhich);
170 static BOOL (WINAPI *pSdbTagIDToTagRef)(HSDB hSDB, PDB pdb, TAGID tiWhich, TAGREF *ptrWhich);
171 static TAGREF (WINAPI *pSdbGetLayerTagRef)(HSDB hsdb, LPCWSTR layerName);
172 static LONGLONG (WINAPI* pSdbMakeIndexKeyFromString)(LPCWSTR);
173
174
175 DEFINE_GUID(GUID_DATABASE_TEST, 0xe39b0eb0, 0x55db, 0x450b, 0x9b, 0xd4, 0xd2, 0x0c, 0x94, 0x84, 0x26, 0x0f);
176 DEFINE_GUID(GUID_MAIN_DATABASE, 0x11111111, 0x1111, 0x1111, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11);
177
178
179 static void Write(HANDLE file, LPCVOID buffer, DWORD size)
180 {
181 DWORD dwWritten = 0;
182 WriteFile(file, buffer, size, &dwWritten, NULL);
183 }
184
185 static void test_Sdb(void)
186 {
187 static const WCHAR temp[] = L"temp";
188 static const WCHAR path1[] = L"temp.sdb";
189 static const WCHAR path2[] = L"temp2.bin";
190 static const WCHAR tag_size_string[] = L"SIZE";
191 static const WCHAR tag_flag_lua_string[] = L"FLAG_LUA";
192 static const WCHAR invalid_tag[] = L"InvalidTag";
193 static const TAG tags[5] = {
194 TAG_SIZE, TAG_FLAG_LUA, TAG_NAME,
195 TAG_STRINGTABLE, TAG_STRINGTABLE_ITEM
196 };
197 WCHAR buffer[6] = { 0 };
198 PDB pdb;
199 QWORD qword;
200 DWORD dword;
201 WORD word;
202 BOOL ret;
203 HANDLE file; /* temp file created for testing purpose */
204 TAG tag;
205 TAGID tagid, ptagid, stringref = 6;
206 LPCWSTR string;
207 PBYTE binary;
208
209 pdb = pSdbCreateDatabase(path1, DOS_PATH);
210 ok(pdb != NULL, "failed to create database\n");
211 if (pdb != NULL)
212 {
213 ret = pSdbWriteDWORDTag(pdb, tags[0], 0xDEADBEEF);
214 ok(ret, "failed to write DWORD tag\n");
215 ret = pSdbWriteQWORDTag(pdb, tags[1], 0xDEADBEEFBABE);
216 ok(ret, "failed to write QWORD tag\n");
217 ret = pSdbWriteStringRefTag(pdb, tags[2], stringref);
218 ok(ret, "failed to write stringref tag\n");
219 tagid = pSdbBeginWriteListTag(pdb, tags[3]);
220 ok(tagid != TAGID_NULL, "unexpected NULL tagid\n");
221 ret = pSdbWriteStringTag(pdb, tags[4], temp);
222 ok(ret, "failed to write string tag\n");
223 ret = pSdbWriteNULLTag(pdb, TAG_GENERAL);
224 ok(ret, "failed to write NULL tag\n");
225 ret = pSdbWriteWORDTag(pdb, TAG_MATCH_MODE, 0xACE);
226 ok(ret, "failed to write WORD tag\n");
227 ret = pSdbEndWriteListTag(pdb, tagid);
228 ok(ret, "failed to update list size\n");
229 /* [Err ][SdbCloseDatabase ] Failed to close the file. */
230 pSdbCloseDatabaseWrite(pdb);
231 }
232
233 /* [Err ][SdbGetDatabaseID ] Failed to get root tag */
234 pdb = pSdbOpenDatabase(path1, DOS_PATH);
235 ok(pdb != NULL, "unexpected NULL handle\n");
236
237 if (pdb)
238 {
239 tagid = pSdbGetFirstChild(pdb, TAGID_ROOT);
240 ok(tagid == _TAGID_ROOT, "unexpected tagid %u, expected %u\n", tagid, _TAGID_ROOT);
241
242 tag = pSdbGetTagFromTagID(pdb, tagid);
243 ok(tag == TAG_SIZE, "unexpected tag 0x%x, expected 0x%x\n", tag, TAG_SIZE);
244
245 string = pSdbTagToString(tag);
246 ok(lstrcmpW(string, tag_size_string) == 0, "unexpected string %s, expected %s\n",
247 wine_dbgstr_w(string), wine_dbgstr_w(tag_size_string));
248
249 dword = pSdbReadDWORDTag(pdb, tagid, 0);
250 ok(dword == 0xDEADBEEF, "unexpected value %u, expected 0xDEADBEEF\n", dword);
251
252 tagid = pSdbGetNextChild(pdb, TAGID_ROOT, tagid);
253 ok(tagid == _TAGID_ROOT + sizeof(TAG) + sizeof(DWORD), "unexpected tagid %u, expected %u\n",
254 tagid, _TAGID_ROOT + sizeof(TAG) + sizeof(DWORD));
255
256 tag = pSdbGetTagFromTagID(pdb, tagid);
257 ok(tag == TAG_FLAG_LUA, "unexpected tag 0x%x, expected 0x%x\n", tag, TAG_FLAG_LUA);
258
259 string = pSdbTagToString(tag);
260 if (g_WinVersion >= WINVER_VISTA)
261 {
262 ok(lstrcmpW(string, tag_flag_lua_string) == 0, "unexpected string %s, expected %s\n",
263 wine_dbgstr_w(string), wine_dbgstr_w(tag_flag_lua_string));
264 }
265 else
266 {
267 ok(lstrcmpW(string, invalid_tag) == 0, "unexpected string %s, expected %s\n",
268 wine_dbgstr_w(string), wine_dbgstr_w(invalid_tag));
269 }
270
271 qword = pSdbReadQWORDTag(pdb, tagid, 0);
272 ok(qword == 0xDEADBEEFBABE, "unexpected value 0x%I64x, expected 0xDEADBEEFBABE\n", qword);
273
274 tagid = pSdbGetNextChild(pdb, TAGID_ROOT, tagid);
275 string = pSdbGetStringTagPtr(pdb, tagid);
276 ok(string && (lstrcmpW(string, temp) == 0), "unexpected string %s, expected %s\n",
277 wine_dbgstr_w(string), wine_dbgstr_w(temp));
278
279 ptagid = pSdbGetNextChild(pdb, TAGID_ROOT, tagid);
280 tagid = pSdbGetFirstChild(pdb, ptagid);
281
282 string = pSdbGetStringTagPtr(pdb, tagid);
283 ok(string && (lstrcmpW(string, temp) == 0), "unexpected string %s, expected %s\n",
284 wine_dbgstr_w(string), wine_dbgstr_w(temp));
285
286 ok(pSdbReadStringTag(pdb, tagid, buffer, 6), "failed to write string to buffer\n");
287 /* [Err ][SdbpReadTagData ] Buffer too small. Avail: 6, Need: 10. */
288 ok(!pSdbReadStringTag(pdb, tagid, buffer, 3), "string was written to buffer, but failure was expected");
289 ok(pSdbGetTagDataSize(pdb, tagid) == 5 * sizeof(WCHAR), "string has unexpected size\n");
290
291 tagid = pSdbGetNextChild(pdb, ptagid, tagid);
292 tag = pSdbGetTagFromTagID(pdb, tagid);
293 ok(tag == TAG_GENERAL, "unexpected tag 0x%x, expected 0x%x\n", tag, TAG_GENERAL);
294 ok(pSdbGetTagDataSize(pdb, tagid) == 0, "null tag with size > 0\n");
295
296 tagid = pSdbGetNextChild(pdb, ptagid, tagid);
297 word = pSdbReadWORDTag(pdb, tagid, 0);
298 ok(word == 0xACE, "unexpected value 0x%x, expected 0x%x\n", word, 0xACE);
299
300 pSdbCloseDatabase(pdb);
301 }
302 DeleteFileW(path1);
303
304 file = CreateFileW(path2, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
305 ok(file != INVALID_HANDLE_VALUE, "failed to open file\n");
306 Write(file, &qword, 8);
307 CloseHandle(file);
308
309 pdb = pSdbCreateDatabase(path1, DOS_PATH);
310 ok(pdb != NULL, "unexpected NULL handle\n");
311
312 if (pdb)
313 {
314 ret = pSdbWriteBinaryTagFromFile(pdb, TAG_DATA_BITS, path2);
315 ok(ret, "failed to write tag from binary file\n");
316 pSdbCloseDatabaseWrite(pdb); /* [Err ][SdbCloseDatabase ] Failed to close the file. */
317 DeleteFileW(path2);
318
319 /* FIXME: doesnt work on win10?! */
320 pdb = pSdbOpenDatabase(path1, DOS_PATH);
321 if (g_WinVersion < WINVER_WIN10)
322 {
323 /* ERROR,SdbOpenDatabaseEx,845,Failed to open SDB - File size too large or small. */
324 ok(pdb != NULL, "unexpected NULL handle\n");
325 }
326 if (pdb)
327 {
328 binary = (PBYTE)pSdbGetBinaryTagData(pdb, _TAGID_ROOT);
329 ok(memcmp(binary, &qword, 8) == 0, "binary data is corrupt\n");
330 ret = pSdbReadBinaryTag(pdb, _TAGID_ROOT, (PBYTE)buffer, 12);
331 ok(ret, "failed to read binary tag\n");
332 ok(memcmp(buffer, &qword, 8) == 0, "binary data is corrupt\n");
333 pSdbCloseDatabase(pdb);
334 }
335 }
336 DeleteFileW(path1);
337 }
338
339 /*
340 - Show that a stringtable is automatically generated,
341 - Show that entries in the stringtable are re-used,
342 - validate multiple lists (for the length)
343 */
344 static void test_write_ex(void)
345 {
346 WCHAR path1[] = {'t','e','s','t','.','s','d','b',0};
347 WCHAR test1[] = {'T','E','S','T',0};
348 WCHAR test2[] = {'t','e','s','t',0};
349 PDB pdb;
350 TAGID tagdb, tagstr;
351 TAG tag;
352 DWORD size;
353 BOOL ret;
354 LPWSTR ptr;
355
356 /* Write a small database */
357 pdb = pSdbCreateDatabase(path1, DOS_PATH);
358 ok(pdb != NULL, "Expected a valid database\n");
359 if (!pdb)
360 return;
361 tagdb = pSdbBeginWriteListTag(pdb, TAG_DATABASE);
362 ok(tagdb == 12, "Expected tag to be 12, was %u\n", tagdb);
363 ret = pSdbWriteStringTag(pdb, TAG_NAME, test1);
364 ret = pSdbWriteStringTag(pdb, TAG_NAME, test2);
365 ok(ret, "Expected SdbWriteStringTag to succeed\n");
366 ret = pSdbEndWriteListTag(pdb, tagdb);
367 ok(ret, "Expected SdbEndWriteListTag to succeed\n");
368
369 tagdb = pSdbBeginWriteListTag(pdb, TAG_DATABASE);
370 ok(tagdb == 30, "Expected tag to be 24, was %u\n", tagdb);
371 ret = pSdbWriteStringTag(pdb, TAG_NAME, test1);
372 ret = pSdbWriteStringTag(pdb, TAG_NAME, test2);
373 ok(ret, "Expected SdbWriteStringTag to succeed\n");
374 ret = pSdbEndWriteListTag(pdb, tagdb);
375 ok(ret, "Expected SdbEndWriteListTag to succeed\n");
376
377 pSdbCloseDatabaseWrite(pdb);
378
379 /* Now validate it's contents */
380 pdb = pSdbOpenDatabase(path1, DOS_PATH);
381 ok(pdb != NULL, "Expected a valid database\n");
382 if (!pdb)
383 return;
384
385 tagdb = pSdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
386 ok(tagdb == 12, "Expected tag to be 12, was %u\n", tagdb);
387 size = pSdbGetTagDataSize(pdb, tagdb);
388 ok(size == 12, "Expected size to be 12, was %u\n", size);
389
390 tagstr = pSdbFindFirstTag(pdb, tagdb, TAG_NAME);
391 ok(tagstr == 18, "Expected string tag to be 18, was %u\n", tagstr);
392 tag = pSdbGetTagFromTagID(pdb, tagstr);
393 ok(tag == TAG_NAME, "Expected tag to be TAG_NAME, was 0x%x\n", (DWORD)tag);
394 size = pSdbGetTagDataSize(pdb, tagstr);
395 ok(size == 4, "Expected size to be 4, was 0x%x\n", size);
396
397 tagstr = pSdbFindNextTag(pdb, tagdb, tagstr);
398 ok(tagstr == 24, "Expected string tag to be 24, was %u\n", tagstr);
399 tag = pSdbGetTagFromTagID(pdb, tagstr);
400 ok(tag == TAG_NAME, "Expected tag to be TAG_NAME, was 0x%x\n", (DWORD)tag);
401 size = pSdbGetTagDataSize(pdb, tagstr);
402 ok(size == 4, "Expected size to be 4, was 0x%x\n", size);
403
404 tagdb = pSdbFindNextTag(pdb, TAGID_ROOT, tagdb);
405 ok(tagdb == 30, "Expected tag to be 30, was %u\n", tagdb);
406 size = pSdbGetTagDataSize(pdb, tagdb);
407 ok(size == 12, "Expected size to be 12, was %u\n", size);
408
409 tagstr = pSdbFindFirstTag(pdb, tagdb, TAG_NAME);
410 ok(tagstr == 36, "Expected string tag to be 36, was %u\n", tagstr);
411 tag = pSdbGetTagFromTagID(pdb, tagstr);
412 ok(tag == TAG_NAME, "Expected tag to be TAG_NAME, was 0x%x\n", (DWORD)tag);
413 size = pSdbGetTagDataSize(pdb, tagstr);
414 ok(size == 4, "Expected size to be 4, was %u\n", size);
415
416 tagstr = pSdbFindNextTag(pdb, tagdb, tagstr);
417 ok(tagstr == 42, "Expected string tag to be 42, was %u\n", tagstr);
418 tag = pSdbGetTagFromTagID(pdb, tagstr);
419 ok(tag == TAG_NAME, "Expected tag to be TAG_NAME, was 0x%x\n", (DWORD)tag);
420 size = pSdbGetTagDataSize(pdb, tagstr);
421 ok(size == 4, "Expected size to be 4, was 0x%x\n", size);
422
423 tagdb = pSdbFindFirstTag(pdb, TAGID_ROOT, TAG_STRINGTABLE);
424 ok(tagdb == 48, "Expected tag to be 48, was %u\n", tagdb);
425 size = pSdbGetTagDataSize(pdb, tagdb);
426 ok(size == 32, "Expected size to be 32, was %u\n", size);
427
428 tagstr = pSdbGetFirstChild(pdb, tagdb);
429 ok(tagstr == 54, "Expected string tag to be 54, was %u\n", tagstr);
430 tag = pSdbGetTagFromTagID(pdb, tagstr);
431 ok(tag == TAG_STRINGTABLE_ITEM, "Expected tag to be TAG_STRINGTABLE_ITEM, was 0x%x\n", (DWORD)tag);
432 size = pSdbGetTagDataSize(pdb, tagstr);
433 ok(size == 10, "Expected size to be 10, was %u\n", size);
434 ptr = pSdbGetStringTagPtr(pdb, tagstr);
435 ok(ptr != NULL, "Expected a valid pointer\n");
436 if (ptr)
437 ok(!wcscmp(ptr, test1), "Expected ptr to be %s, was %s\n", wine_dbgstr_w(test1), wine_dbgstr_w(ptr));
438
439 tagstr = pSdbGetNextChild(pdb, tagdb, tagstr);
440 ok(tagstr == 70, "Expected string tag to be 70, was %u\n", tagstr);
441 tag = pSdbGetTagFromTagID(pdb, tagstr);
442 ok(tag == TAG_STRINGTABLE_ITEM, "Expected tag to be TAG_STRINGTABLE_ITEM, was 0x%x\n", (DWORD)tag);
443 size = pSdbGetTagDataSize(pdb, tagstr);
444 ok(size == 10, "Expected size to be 10, was %u\n", size);
445 ptr = pSdbGetStringTagPtr(pdb, tagstr);
446 ok(ptr != NULL, "Expected a valid pointer\n");
447 if (ptr)
448 ok(!wcscmp(ptr, test2), "Expected ptr to be %s, was %s\n", wine_dbgstr_w(test2), wine_dbgstr_w(ptr));
449
450 pSdbCloseDatabase(pdb);
451 }
452
453
454 static void write_db_strings(const WCHAR* name, const WCHAR* data[], size_t count)
455 {
456 PDB pdb;
457 size_t n;
458 BOOL ret;
459
460 pdb = pSdbCreateDatabase(name, DOS_PATH);
461 ok(pdb != NULL, "Failed to create db for case %u\n", count);
462 for (n = 0; n < count; ++n)
463 {
464 ret = pSdbWriteStringTag(pdb, TAG_NAME, data[n]);
465 ok(ret, "Failed to write string %u/%u\n", n, count);
466 }
467 pSdbCloseDatabaseWrite(pdb);
468 }
469
470 static void test_stringtable()
471 {
472 static const WCHAR path1[] = {'t','e','s','t','.','s','d','b',0};
473 static const WCHAR test1[] = {'t','e','s','t','1',0};
474 static const WCHAR test2[] = {'T','e','s','t','1',0};
475 static const WCHAR test3[] = {'T','E','s','t','1',0};
476 static const WCHAR test4[] = {'T','E','S','T','1',0};
477 static const WCHAR test5[] = {'T','E','S','T','2',0};
478 static const WCHAR lipsum[] = {'L','o','r','e','m',' ','i','p','s','u','m',' ','d','o','l','o','r',' ','s','i','t',' ','a','m','e','t',',',' ','c','o','n','s','e','c','t','e','t','u','r',' ','a','d','i','p','i','s','c','i','n','g',' ','e','l','i','t','.',' ','N','u','l','l','a',' ','a','n','t','e',' ','r','i','s','u','s',',',' ','m','a','l','e','s','u','a','d','a',' ','s','e','d',' ','i','a','c','u','l','i','s',' ','l','u','c','t','u','s',',',' ','o','r','n','a','r','e',' ','p','u','l','v','i','n','a','r',' ','v','e','l','i','t','.',' ','L','o','r','e','m',' ','i','p','s','u','m',' ','d','o','l','o','r',' ','s','i','t',' ','a','m','e','t',',',' ','c','o','n','s','e','c','t','e','t','u','r',' ','a','d','i','p','i','s','c','i','n','g',' ','e','l','i','t','.',' ','I','n','t','e','g','e','r',' ','q','u','i','s',' ','f','e','l','i','s',' ','u','t',' ','l','e','o',' ','e','l','e','i','f','e','n','d',' ','u','l','t','r','i','c','e','s',' ','f','i','n','i','b','u','s',' ','e','u',' ','d','o','l','o','r','.',' ','I','n',' ','b','i','b','e','n','d','u','m',',',' ','e','r','o','s',' ','e','u',' ','f','a','u','c','i','b','u','s',' ','c','o','n','s','e','q','u','a','t',',',' ','n','i','s','i',' ','m','a','g','n','a',' ','v','e','n','e','n','a','t','i','s',' ','j','u','s','t','o',',',' ','a','t',' ','t','r','i','s','t','i','q','u','e',' ','m','e','t','u','s',' ','d','o','l','o','r',' ','u','t',' ','r','i','s','u','s','.',' ','N','u','n','c',' ','e','u',' ','o','d','i','o',' ','d','i','g','n','i','s','s','i','m',',',' ','o','r','n','a','r','e',' ','a','n','t','e',' ','g','r','a','v','i','d','a',',',' ','l','o','b','o','r','t','i','s',' ','e','r','o','s','.',' ','C','r','a','s',' ','s','e','m',' ','e','x',',',' ','c','o','n','s','e','c','t','e','t','u','r',' ','p','u','l','v','i','n','a','r',' ','t','i','n','c','i','d','u','n','t',' ','e','u',',',' ','c','o','n','g','u','e',' ','a',' ','e','r','o','s','.',' ','C','u','r','a','b','i','t','u','r',' ','e','r','o','s',' ','e','r','a','t',',',' ','p','e','l','l','e','n','t','e','s','q','u','e',' ','e','t',' ','n','i','b','h',' ','q','u','i','s',',',' ','i','n','t','e','r','d','u','m',' ','t','e','m','p','o','r',' ','o','d','i','o','.',' ','E','t','i','a','m',' ','s','a','p','i','e','n',' ','s','a','p','i','e','n',',',' ','a','l','i','q','u','a','m',' ','u','t',' ','a','l','i','q','u','a','m',' ','a','t',',',' ','s','a','g','i','t','t','i','s',' ','e','u',' ','m','a','g','n','a','.',' ','M','a','e','c','e','n','a','s',' ','m','a','g','n','a',' ','m','a','g','n','a',',',' ','s','u','s','c','i','p','i','t',' ','u','t',' ','l','o','r','e','m',' ','u','t',',',' ','v','a','r','i','u','s',' ','p','r','e','t','i','u','m',' ','f','e','l','i','s','.',' ','I','n','t','e','g','e','r',' ','t','i','n','c','i','d','u','n','t',',',' ','m','e','t','u','s',' ','v','e','l',' ','s','o','l','l','i','c','i','t','u','d','i','n',' ','f','i','n','i','b','u','s',',',' ','f','e','l','i','s',' ','e','r','a','t',' ','m','o','l','e','s','t','i','e',' ','u','r','n','a',',',' ','a',' ','c','o','n','d','i','m','e','n','t','u','m',' ','a','u','g','u','e',' ','a','r','c','u',' ','v','i','t','a','e',' ','r','i','s','u','s','.',' ','E','t','i','a','m',' ','i','d',' ','s','a','g','i','t','t','i','s',' ','q','u','a','m','.',' ','M','o','r','b','i',' ','a',' ','u','l','t','r','i','c','i','e','s',' ','n','u','n','c','.',' ','P','h','a','s','e','l','l','u','s',' ','e','r','o','s',' ','r','i','s','u','s',',',' ','c','u','r','s','u','s',' ','u','l','l','a','m','c','o','r','p','e','r',' ','m','a','s','s','a',' ','s','e','d',',',' ','d','i','g','n','i','s','s','i','m',' ','c','o','n','s','e','q','u','a','t',' ','l','i','g','u','l','a','.',' ','A','l','i','q','u','a','m',' ','t','u','r','p','i','s',' ','a','r','c','u',',',' ','a','c','c','u','m','s','a','n',' ','q','u','i','s',' ','s','a','p','i','e','n',' ','v','i','t','a','e',',',' ','l','a','c','i','n','i','a',' ','e','u','i','s','m','o','d',' ','n','i','s','l','.',' ','M','a','u','r','i','s',' ','i','d',' ','f','e','l','i','s',' ','s','e','m','.',0};
479 /* Last char changed from '.' to '!' */
480 static const WCHAR lipsum2[] = {'L','o','r','e','m',' ','i','p','s','u','m',' ','d','o','l','o','r',' ','s','i','t',' ','a','m','e','t',',',' ','c','o','n','s','e','c','t','e','t','u','r',' ','a','d','i','p','i','s','c','i','n','g',' ','e','l','i','t','.',' ','N','u','l','l','a',' ','a','n','t','e',' ','r','i','s','u','s',',',' ','m','a','l','e','s','u','a','d','a',' ','s','e','d',' ','i','a','c','u','l','i','s',' ','l','u','c','t','u','s',',',' ','o','r','n','a','r','e',' ','p','u','l','v','i','n','a','r',' ','v','e','l','i','t','.',' ','L','o','r','e','m',' ','i','p','s','u','m',' ','d','o','l','o','r',' ','s','i','t',' ','a','m','e','t',',',' ','c','o','n','s','e','c','t','e','t','u','r',' ','a','d','i','p','i','s','c','i','n','g',' ','e','l','i','t','.',' ','I','n','t','e','g','e','r',' ','q','u','i','s',' ','f','e','l','i','s',' ','u','t',' ','l','e','o',' ','e','l','e','i','f','e','n','d',' ','u','l','t','r','i','c','e','s',' ','f','i','n','i','b','u','s',' ','e','u',' ','d','o','l','o','r','.',' ','I','n',' ','b','i','b','e','n','d','u','m',',',' ','e','r','o','s',' ','e','u',' ','f','a','u','c','i','b','u','s',' ','c','o','n','s','e','q','u','a','t',',',' ','n','i','s','i',' ','m','a','g','n','a',' ','v','e','n','e','n','a','t','i','s',' ','j','u','s','t','o',',',' ','a','t',' ','t','r','i','s','t','i','q','u','e',' ','m','e','t','u','s',' ','d','o','l','o','r',' ','u','t',' ','r','i','s','u','s','.',' ','N','u','n','c',' ','e','u',' ','o','d','i','o',' ','d','i','g','n','i','s','s','i','m',',',' ','o','r','n','a','r','e',' ','a','n','t','e',' ','g','r','a','v','i','d','a',',',' ','l','o','b','o','r','t','i','s',' ','e','r','o','s','.',' ','C','r','a','s',' ','s','e','m',' ','e','x',',',' ','c','o','n','s','e','c','t','e','t','u','r',' ','p','u','l','v','i','n','a','r',' ','t','i','n','c','i','d','u','n','t',' ','e','u',',',' ','c','o','n','g','u','e',' ','a',' ','e','r','o','s','.',' ','C','u','r','a','b','i','t','u','r',' ','e','r','o','s',' ','e','r','a','t',',',' ','p','e','l','l','e','n','t','e','s','q','u','e',' ','e','t',' ','n','i','b','h',' ','q','u','i','s',',',' ','i','n','t','e','r','d','u','m',' ','t','e','m','p','o','r',' ','o','d','i','o','.',' ','E','t','i','a','m',' ','s','a','p','i','e','n',' ','s','a','p','i','e','n',',',' ','a','l','i','q','u','a','m',' ','u','t',' ','a','l','i','q','u','a','m',' ','a','t',',',' ','s','a','g','i','t','t','i','s',' ','e','u',' ','m','a','g','n','a','.',' ','M','a','e','c','e','n','a','s',' ','m','a','g','n','a',' ','m','a','g','n','a',',',' ','s','u','s','c','i','p','i','t',' ','u','t',' ','l','o','r','e','m',' ','u','t',',',' ','v','a','r','i','u','s',' ','p','r','e','t','i','u','m',' ','f','e','l','i','s','.',' ','I','n','t','e','g','e','r',' ','t','i','n','c','i','d','u','n','t',',',' ','m','e','t','u','s',' ','v','e','l',' ','s','o','l','l','i','c','i','t','u','d','i','n',' ','f','i','n','i','b','u','s',',',' ','f','e','l','i','s',' ','e','r','a','t',' ','m','o','l','e','s','t','i','e',' ','u','r','n','a',',',' ','a',' ','c','o','n','d','i','m','e','n','t','u','m',' ','a','u','g','u','e',' ','a','r','c','u',' ','v','i','t','a','e',' ','r','i','s','u','s','.',' ','E','t','i','a','m',' ','i','d',' ','s','a','g','i','t','t','i','s',' ','q','u','a','m','.',' ','M','o','r','b','i',' ','a',' ','u','l','t','r','i','c','i','e','s',' ','n','u','n','c','.',' ','P','h','a','s','e','l','l','u','s',' ','e','r','o','s',' ','r','i','s','u','s',',',' ','c','u','r','s','u','s',' ','u','l','l','a','m','c','o','r','p','e','r',' ','m','a','s','s','a',' ','s','e','d',',',' ','d','i','g','n','i','s','s','i','m',' ','c','o','n','s','e','q','u','a','t',' ','l','i','g','u','l','a','.',' ','A','l','i','q','u','a','m',' ','t','u','r','p','i','s',' ','a','r','c','u',',',' ','a','c','c','u','m','s','a','n',' ','q','u','i','s',' ','s','a','p','i','e','n',' ','v','i','t','a','e',',',' ','l','a','c','i','n','i','a',' ','e','u','i','s','m','o','d',' ','n','i','s','l','.',' ','M','a','u','r','i','s',' ','i','d',' ','f','e','l','i','s',' ','s','e','m','!',0};
481 static const WCHAR empty[] = {0};
482 static const WCHAR* all[] = { test1, test2, test3, test4, test5, lipsum, lipsum2, empty };
483 static const TAGID expected_str[] = { 0xc, 0x12, 0x18, 0x1e, 0x24, 0x2a, 0x30, 0x36 };
484 static const TAGID expected_tab[] = { 6, 0x18, 0x2a, 0x3c, 0x4e, 0x60, 0x846, 0x102c };
485 size_t n, j;
486
487 for (n = 0; n < (sizeof(all) / sizeof(all[0])); ++n)
488 {
489 PDB pdb;
490 TAGID tagstr, table, expected_table;
491
492 write_db_strings(path1, all, n+1);
493
494 pdb = pSdbOpenDatabase(path1, DOS_PATH);
495 ok(pdb != NULL, "Expected a valid database\n");
496 if (!pdb)
497 {
498 DeleteFileW(path1);
499 continue;
500 }
501 tagstr = pSdbFindFirstTag(pdb, TAGID_ROOT, TAG_NAME);
502 for (j = 0; j <= n; ++j)
503 {
504 ok(tagstr == expected_str[j], "Expected tagstr to be 0x%x, was 0x%x for %u/%u\n", expected_str[j], tagstr, j, n);
505 if (tagstr)
506 {
507 LPWSTR data;
508 DWORD size;
509 TAG tag = pSdbGetTagFromTagID(pdb, tagstr);
510 ok(tag == TAG_NAME, "Expected tag to be TAG_NAME, was 0x%x for %u/%u\n", tag, j, n);
511 size = pSdbGetTagDataSize(pdb, tagstr);
512 ok(size == 4, "Expected datasize to be 4, was %u for %u/%u\n", size, j, n);
513 data = pSdbGetStringTagPtr(pdb, tagstr);
514 ok(data && !wcsicmp(data, all[j]), "Expected data to be %s was %s for %u/%u\n", wine_dbgstr_w(all[j]), wine_dbgstr_w(data), j, n);
515 }
516 tagstr = pSdbFindNextTag(pdb, TAGID_ROOT, tagstr);
517 }
518 ok(tagstr == TAGID_NULL, "Expected to be at the end for %u\n", n);
519
520
521 table = pSdbFindFirstTag(pdb, TAGID_ROOT, TAG_STRINGTABLE);
522 expected_table = 0xc + (n+1)*6;
523 ok(table == expected_table, "Expected to find a stringtable at 0x%x instead of 0x%x for %u\n", expected_table, table, n);
524 if (table)
525 {
526 tagstr = pSdbFindFirstTag(pdb, table, TAG_STRINGTABLE_ITEM);
527 for (j = 0; j <= n; ++j)
528 {
529 ok(tagstr == (expected_tab[j] + expected_table), "Expected tagstr to be 0x%x, was 0x%x for %u/%u\n", (expected_tab[j] + expected_table), tagstr, j, n);
530 if (tagstr)
531 {
532 LPWSTR data;
533 DWORD size, expected_size;
534 TAG tag = pSdbGetTagFromTagID(pdb, tagstr);
535 ok(tag == TAG_STRINGTABLE_ITEM, "Expected tag to be TAG_NAME, was 0x%x for %u/%u\n", tag, j, n);
536 size = pSdbGetTagDataSize(pdb, tagstr);
537 expected_size = (lstrlenW(all[j])+1) * 2;
538 ok(size == expected_size, "Expected datasize to be %u, was %u for %u/%u\n", expected_size, size, j, n);
539 data = pSdbGetStringTagPtr(pdb, tagstr);
540 ok(data && !wcsicmp(data, all[j]), "Expected data to be %s was %s for %u/%u\n", wine_dbgstr_w(all[j]), wine_dbgstr_w(data), j, n);
541 }
542 tagstr = pSdbFindNextTag(pdb, TAGID_ROOT, tagstr);
543 }
544 ok(tagstr == TAGID_NULL, "Expected to be at the end for %u\n", n);
545 }
546
547 pSdbCloseDatabase(pdb);
548 DeleteFileW(path1);
549 }
550 }
551
552 static void match_strw_attr_imp(PDB pdb, TAGID parent, TAG find, const WCHAR* compare)
553 {
554 TAGID attr = pSdbFindFirstTag(pdb, parent, find);
555 winetest_ok(attr != TAG_NULL, "Could not find: %x\n", find);
556 if (attr != TAG_NULL)
557 {
558 LPWSTR name = pSdbGetStringTagPtr(pdb, attr);
559 winetest_ok(name != NULL, "Could not convert attr to str.\n");
560 if (name)
561 {
562 winetest_ok(wcscmp(name, compare) == 0, "Expected tagid %x to be %s, was %s\n", attr, wine_dbgstr_w(compare), wine_dbgstr_w(name));
563 }
564 }
565 }
566
567 static void match_dw_attr_imp(PDB pdb, TAGID parent, TAG find, DWORD compare)
568 {
569 TAGID attr = pSdbFindFirstTag(pdb, parent, find);
570 winetest_ok(attr != TAG_NULL, "Could not find: %x\n", find);
571 if (attr != TAG_NULL)
572 {
573 DWORD val = pSdbReadDWORDTag(pdb, attr, 0x1234567);
574 winetest_ok(val == compare, "Expected tagid %x to be 0x%x, was 0x%x\n", attr, compare, val);
575 }
576 }
577
578 static void match_qw_attr_imp(PDB pdb, TAGID parent, TAG find, QWORD compare)
579 {
580 TAGID attr = pSdbFindFirstTag(pdb, parent, find);
581 winetest_ok(attr != TAG_NULL, "Could not find: %x\n", find);
582 if (attr != TAG_NULL)
583 {
584 QWORD val = pSdbReadQWORDTag(pdb, attr, 0x123456789abcdef);
585 winetest_ok(val == compare, "Expected tagid %x to be 0x%I64x, was 0x%I64x\n", attr, compare, val);
586 }
587 }
588
589 static void match_guid_attr_imp(PDB pdb, TAGID parent, TAG find, const GUID* compare)
590 {
591 TAGID attr = pSdbFindFirstTag(pdb, parent, find);
592 winetest_ok(attr != TAG_NULL, "Could not find: %x\n", find);
593 if (attr != TAG_NULL)
594 {
595 GUID guid = { 0 };
596 BOOL result = pSdbReadBinaryTag(pdb, attr, (PBYTE)&guid, sizeof(guid));
597 winetest_ok(result, "expected pSdbReadBinaryTag not to fail.\n");
598 winetest_ok(IsEqualGUID(guid, *compare), "expected guids to be equal(%s:%s)\n", wine_dbgstr_guid(&guid), wine_dbgstr_guid(compare));
599 }
600 }
601
602 #define match_strw_attr (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : match_strw_attr_imp
603 #define match_dw_attr (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : match_dw_attr_imp
604 #define match_qw_attr (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : match_qw_attr_imp
605 #define match_guid_attr (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : match_guid_attr_imp
606
607
608 //The application name cannot contain any of the following characters:
609 // \ / < > : * ? | "
610
611 static void check_db_properties(PDB pdb, TAGID root)
612 {
613 TAGID iter = pSdbFindFirstTag(pdb, root, TAG_DATABASE_ID);
614 ok(iter != TAGID_NULL, "expected a result, got TAGID_NULL\n");
615 if (iter != TAGID_NULL)
616 {
617 GUID guid = { 0 }, guid2 = { 0 };
618 BOOL result = pSdbReadBinaryTag(pdb, iter, (PBYTE)&guid, sizeof(guid));
619 ok(result, "expected SdbReadBinaryTag not to fail.\n");
620 if (result)
621 {
622 WCHAR guid_wstr[50];
623 result = pSdbGUIDToString(&guid, guid_wstr, 50);
624 ok(result, "expected SdbGUIDToString not to fail.\n");
625 if (result)
626 {
627 char guid_str[50];
628 WideCharToMultiByte(CP_ACP, 0, guid_wstr, -1, guid_str, sizeof(guid_str), NULL, NULL);
629 ok_str(guid_str, "{e39b0eb0-55db-450b-9bd4-d20c9484260f}");
630 }
631 ok(pSdbGetDatabaseID(pdb, &guid2), "expected SdbGetDatabaseID not to fail.\n");
632 ok(IsEqualGUID(guid, guid2), "expected guids to be equal(%s:%s)\n", wine_dbgstr_guid(&guid), wine_dbgstr_guid(&guid2));
633 }
634 }
635 match_qw_attr(pdb, root, TAG_TIME, 0x1d1b91a02c0d63e);
636 match_strw_attr(pdb, root, TAG_COMPILER_VERSION, L"2.1.0.3");
637 match_strw_attr(pdb, root, TAG_NAME, L"apphelp_test1");
638 match_dw_attr(pdb, root, TAG_OS_PLATFORM, 1);
639 }
640
641 static void check_db_layer(PDB pdb, TAGID layer)
642 {
643 TAGID shimref, inexclude, is_include;
644 ok(layer != TAGID_NULL, "Expected a valid layer, got NULL\n");
645 if (!layer)
646 return;
647
648 match_strw_attr(pdb, layer, TAG_NAME, L"TestNewMode");
649 shimref = pSdbFindFirstTag(pdb, layer, TAG_SHIM_REF);
650 ok(shimref != TAGID_NULL, "Expected a valid shim ref, got NULL\n");
651 if (!shimref)
652 return;
653
654 match_strw_attr(pdb, shimref, TAG_NAME, L"VirtualRegistry");
655 match_strw_attr(pdb, shimref, TAG_COMMAND_LINE, L"ThemeActive");
656 inexclude = pSdbFindFirstTag(pdb, shimref, TAG_INEXCLUD);
657 ok(inexclude != TAGID_NULL, "Expected a valid in/exclude ref, got NULL\n");
658 if (!inexclude)
659 return;
660
661 is_include = pSdbFindFirstTag(pdb, inexclude, TAG_INCLUDE);
662 ok(is_include == TAGID_NULL, "Expected a NULL include ref, but got one anyway.\n");
663 match_strw_attr(pdb, inexclude, TAG_MODULE, L"exclude.dll");
664
665 inexclude = pSdbFindNextTag(pdb, shimref, inexclude);
666 ok(inexclude != TAGID_NULL, "Expected a valid in/exclude ref, got NULL\n");
667 if (!inexclude)
668 return;
669
670 is_include = pSdbFindFirstTag(pdb, inexclude, TAG_INCLUDE);
671 ok(is_include != TAGID_NULL, "Expected a valid include ref, got NULL\n");
672 match_strw_attr(pdb, inexclude, TAG_MODULE, L"include.dll");
673 }
674
675 static void check_matching_file(PDB pdb, TAGID exe, TAGID matching_file, int num)
676 {
677 ok(matching_file != TAGID_NULL, "Expected to find atleast 1 matching file.\n");
678 if (matching_file == TAGID_NULL)
679 return;
680
681 ok(num < 4, "Too many matches, expected only 4!\n");
682 if (num >= 4)
683 return;
684
685
686 match_strw_attr(pdb, matching_file, TAG_NAME, L"*");
687 match_strw_attr(pdb, matching_file, TAG_COMPANY_NAME, L"CompanyName");
688 match_strw_attr(pdb, matching_file, TAG_PRODUCT_NAME, L"ProductName");
689 match_strw_attr(pdb, matching_file, TAG_PRODUCT_VERSION, L"1.0.0.1");
690 match_strw_attr(pdb, matching_file, TAG_FILE_VERSION, L"1.0.0.0");
691
692 if (num == 0 || num == 3)
693 {
694 match_qw_attr(pdb, matching_file, TAG_UPTO_BIN_PRODUCT_VERSION, 0x1000000000001);
695 match_qw_attr(pdb, matching_file, TAG_UPTO_BIN_FILE_VERSION, 0x1000000000000);
696 }
697 if (num == 1 || num == 3)
698 {
699 match_dw_attr(pdb, matching_file, TAG_PE_CHECKSUM, 0xbaad);
700 }
701 if (num != 0)
702 {
703 match_qw_attr(pdb, matching_file, TAG_BIN_PRODUCT_VERSION, 0x1000000000001);
704 match_qw_attr(pdb, matching_file, TAG_BIN_FILE_VERSION, 0x1000000000000);
705 }
706 if (num == 3)
707 {
708 match_dw_attr(pdb, matching_file, TAG_SIZE, 0x800);
709 match_dw_attr(pdb, matching_file, TAG_CHECKSUM, 0x178bd629);
710 match_strw_attr(pdb, matching_file, TAG_FILE_DESCRIPTION, L"FileDescription");
711 match_dw_attr(pdb, matching_file, TAG_MODULE_TYPE, 3);
712 match_dw_attr(pdb, matching_file, TAG_VERFILEOS, 4);
713 match_dw_attr(pdb, matching_file, TAG_VERFILETYPE, 1);
714 match_dw_attr(pdb, matching_file, TAG_LINKER_VERSION, 0x40002);
715 match_strw_attr(pdb, matching_file, TAG_ORIGINAL_FILENAME, L"OriginalFilename");
716 match_strw_attr(pdb, matching_file, TAG_INTERNAL_NAME, L"InternalName");
717 match_strw_attr(pdb, matching_file, TAG_LEGAL_COPYRIGHT, L"LegalCopyright");
718 match_dw_attr(pdb, matching_file, TAG_LINK_DATE, 0x12345);
719 match_dw_attr(pdb, matching_file, TAG_UPTO_LINK_DATE, 0x12345);
720 }
721 if (num > 3)
722 {
723 ok(0, "unknown case: %d\n", num);
724 }
725 matching_file = pSdbFindNextTag(pdb, exe, matching_file);
726 if (num == 2)
727 {
728 ok(matching_file != TAGID_NULL, "Did expect a secondary match on %d\n", num);
729 match_strw_attr(pdb, matching_file, TAG_NAME, L"test_checkfile.txt");
730 match_dw_attr(pdb, matching_file, TAG_SIZE, 0x4);
731 match_dw_attr(pdb, matching_file, TAG_CHECKSUM, 0xb0b0b0b0);
732 }
733 else
734 {
735 ok(matching_file == TAGID_NULL, "Did not expect a secondary match on %d\n", num);
736 }
737 }
738
739 // "C:\WINDOWS\system32\pcaui.exe" /g {bf39e0e6-c61c-4a22-8802-3ea8ad00b655} /x {4e50c93f-b863-4dfa-bae2-d80ef4ce5c89} /a "apphelp_name_allow" /v "apphelp_vendor_allow" /s "Allow it!" /b 1 /f 0 /k 0 /e "C:\Users\Mark\AppData\Local\Temp\apphelp_test\test_allow.exe" /u "http://reactos.org/allow" /c
740 // "C:\WINDOWS\system32\pcaui.exe" /g {fa150915-1244-4169-a4ba-fc098c442840} /x {156720e1-ef98-4d04-965a-d85de05e6d9f} /a "apphelp_name_disallow" /v "apphelp_vendor_disallow" /s "Not allowed!" /b 2 /f 0 /k 0 /e "C:\Users\Mark\AppData\Local\Temp\apphelp_test\test_disallow.exe" /u "http://reactos.org/disallow" /c
741
742 static void check_matching_apphelp(PDB pdb, TAGID apphelp, int num)
743 {
744 if (num == 0)
745 {
746 /*
747 [Window Title]
748 Program Compatibility Assistant
749
750 [Main Instruction]
751 This program has known compatibility issues
752
753 [Expanded Information]
754 Allow it!
755
756 [^] Hide details [ ] Don't show this message again [Check for solutions online] [Run program] [Cancel]
757 */
758 match_dw_attr(pdb, apphelp, TAG_FLAGS, 1);
759 match_dw_attr(pdb, apphelp, TAG_PROBLEMSEVERITY, 1);
760 match_dw_attr(pdb, apphelp, TAG_HTMLHELPID, 1);
761 match_dw_attr(pdb, apphelp, TAG_APP_NAME_RC_ID, 0x6f0072);
762 match_dw_attr(pdb, apphelp, TAG_VENDOR_NAME_RC_ID, 0x720067);
763 match_dw_attr(pdb, apphelp, TAG_SUMMARY_MSG_RC_ID, 0);
764 }
765 else
766 {
767 /*
768 [Window Title]
769 Program Compatibility Assistant
770
771 [Main Instruction]
772 This program is blocked due to compatibility issues
773
774 [Expanded Information]
775 Not allowed!
776
777 [^] Hide details [Check for solutions online] [Cancel]
778 */
779 match_dw_attr(pdb, apphelp, TAG_FLAGS, 1);
780 match_dw_attr(pdb, apphelp, TAG_PROBLEMSEVERITY, 2);
781 match_dw_attr(pdb, apphelp, TAG_HTMLHELPID, 2);
782 match_dw_attr(pdb, apphelp, TAG_APP_NAME_RC_ID, 0x320020);
783 match_dw_attr(pdb, apphelp, TAG_VENDOR_NAME_RC_ID, 0x38002e);
784 match_dw_attr(pdb, apphelp, TAG_SUMMARY_MSG_RC_ID, 0);
785 }
786 apphelp = pSdbFindNextTag(pdb, apphelp, apphelp);
787 ok(apphelp == TAGID_NULL, "Did not expect a secondary match on %d\n", num);
788 }
789
790 static void check_matching_layer(PDB pdb, TAGID layer, int num)
791 {
792 if (num == 2)
793 {
794 match_dw_attr(pdb, layer, TAG_LAYER_TAGID, 0x18e);
795 match_strw_attr(pdb, layer, TAG_NAME, L"TestNewMode");
796 }
797 else
798 {
799 TAGID layer_tagid = pSdbFindFirstTag(pdb, layer, TAG_LAYER_TAGID);
800 ok(layer_tagid == TAGID_NULL, "expected not to find a layer tagid, got %x\n", layer_tagid);
801 match_strw_attr(pdb, layer, TAG_NAME, L"WinSrv03");
802 }
803 }
804
805 static struct
806 {
807 const WCHAR* name;
808 const WCHAR* app_name;
809 const WCHAR* vendor;
810 GUID exe_id;
811 const WCHAR* extra_file;
812 DWORD dwLayerCount;
813 TAGREF atrExes_0;
814 DWORD adwExeFlags_0;
815 TAGREF atrLayers_0;
816 TAGREF trApphelp;
817 const char* env_var;
818 } test_exedata[5] = {
819 {
820 L"test_allow.exe",
821 L"apphelp_name_allow",
822 L"apphelp_vendor_allow",
823 { 0x4e50c93f, 0xb863, 0x4dfa, { 0xba, 0xe2, 0xd8, 0x0e, 0xf4, 0xce, 0x5c, 0x89 } },
824 NULL,
825 0,
826 0x1c6,
827 0x1000,
828 0,
829 0x1c6,
830 NULL,
831 },
832 {
833 L"test_disallow.exe",
834 L"apphelp_name_disallow",
835 L"apphelp_vendor_disallow",
836 { 0x156720e1, 0xef98, 0x4d04, { 0x96, 0x5a, 0xd8, 0x5d, 0xe0, 0x5e, 0x6d, 0x9f } },
837 NULL,
838 0,
839 0x256,
840 0x3000,
841 0,
842 0x256,
843 NULL,
844 },
845 {
846 L"test_new.exe",
847 L"fixnew_name",
848 L"fixnew_vendor",
849 { 0xce70ef69, 0xa21d, 0x408b, { 0x84, 0x5b, 0xf9, 0x9e, 0xac, 0x06, 0x09, 0xe7 } },
850 L"test_checkfile.txt",
851 1,
852 0x2ec,
853 0,
854 0x18e,
855 0,
856 NULL,
857 },
858 {
859 L"test_w2k3.exe",
860 L"fix_name",
861 L"fix_vendor",
862 { 0xb4ead144, 0xf640, 0x4e4b, { 0x94, 0xc4, 0x0c, 0x7f, 0xa8, 0x66, 0x23, 0xb0 } },
863 NULL,
864 0,
865 0x37c,
866 0,
867 0,
868 0,
869 NULL,
870 },
871 {
872 L"test_unknown_file.exe",
873 L"apphelp_name_allow",
874 L"apphelp_vendor_allow",
875 { 0x00000000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
876 NULL,
877 1,
878 0,
879 0,
880 0x18e,
881 0,
882 "TestNewMode",
883 },
884 };
885
886 static void check_db_exes(PDB pdb, TAGID root)
887 {
888 int num = 0;
889 TAGID exe = pSdbFindFirstTag(pdb, root, TAG_EXE);
890 TAGID altExe = pSdbFindFirstNamedTag(pdb, root, TAG_EXE, TAG_NAME, L"test_allow.exe");
891 ok_hex(altExe, (int)exe);
892 while (exe != TAGID_NULL)
893 {
894 TAGID apphelp, layer;
895 ok(num < 4, "Too many matches, expected only 4!\n");
896 if (num >= 4)
897 break;
898 match_strw_attr(pdb, exe, TAG_NAME, test_exedata[num].name);
899 match_strw_attr(pdb, exe, TAG_APP_NAME, test_exedata[num].app_name);
900 match_strw_attr(pdb, exe, TAG_VENDOR, test_exedata[num].vendor);
901 match_guid_attr(pdb, exe, TAG_EXE_ID, &test_exedata[num].exe_id);
902 check_matching_file(pdb, exe, pSdbFindFirstTag(pdb, exe, TAG_MATCHING_FILE), num);
903 apphelp = pSdbFindFirstTag(pdb, exe, TAG_APPHELP);
904 if (num == 0 || num == 1)
905 {
906 ok(apphelp != TAGID_NULL, "Expected to find a valid apphelp match on %d.\n", num);
907 if (apphelp)
908 check_matching_apphelp(pdb, apphelp, num);
909 }
910 else
911 {
912 ok(apphelp == TAGID_NULL, "Did not expect an apphelp match on %d\n", num);
913 }
914 layer = pSdbFindFirstTag(pdb, exe, TAG_LAYER);
915 if (num == 2 || num == 3)
916 {
917 ok(layer != TAGID_NULL, "Expected to find a valid layer match on %d.\n", num);
918 if (layer)
919 check_matching_layer(pdb, layer, num);
920 }
921 else
922 {
923 ok(layer == TAGID_NULL, "Did not expect a layer match on %d\n", num);
924 }
925 ++num;
926 exe = pSdbFindNextTag(pdb, root, exe);
927 }
928 ok(num == 4, "Expected to find 4 exe tags, found: %d\n", num);
929 }
930
931 static struct
932 {
933 DWORD htmlhelpid;
934 const WCHAR* link;
935 const WCHAR* apphelp_title;
936 const WCHAR* apphelp_details;
937 } test_layerdata[2] = {
938 {
939 2,
940 L"http://reactos.org/disallow",
941 L"apphelp_name_disallow",
942 L"Not allowed!",
943 },
944 {
945 1,
946 L"http://reactos.org/allow",
947 L"apphelp_name_allow",
948 L"Allow it!",
949 },
950 };
951
952 static void check_db_apphelp(PDB pdb, TAGID root)
953 {
954 int num = 0;
955 TAGID apphelp = pSdbFindFirstTag(pdb, root, TAG_APPHELP);
956 while (apphelp != TAGID_NULL)
957 {
958 TAGID link;
959 ok(num < 2, "Too many matches, expected only 4!\n");
960 if (num >= 2)
961 break;
962 match_dw_attr(pdb, apphelp, TAG_HTMLHELPID, test_layerdata[num].htmlhelpid);
963 link = pSdbFindFirstTag(pdb, apphelp, TAG_LINK);
964 ok(link != TAGID_NULL, "expected to find a link tag\n");
965 if (link != TAGID_NULL)
966 {
967 match_strw_attr(pdb, link, TAG_LINK_URL, test_layerdata[num].link);
968 }
969 match_strw_attr(pdb, apphelp, TAG_APPHELP_TITLE, test_layerdata[num].apphelp_title);
970 match_strw_attr(pdb, apphelp, TAG_APPHELP_DETAILS, test_layerdata[num].apphelp_details);
971 apphelp = pSdbFindNextTag(pdb, root, apphelp);
972 num++;
973 }
974 ok(num == 2, "Expected to find 2 layer tags, found: %d\n", num);
975 }
976
977 static void test_CheckDatabaseManually(void)
978 {
979 static const WCHAR path[] = {'t','e','s','t','_','d','b','.','s','d','b',0};
980 TAGID root;
981 PDB pdb;
982 BOOL ret;
983 DWORD ver_hi, ver_lo;
984
985 test_create_db(L"test_db.sdb", g_WinVersion >= WINVER_WIN10);
986
987 /* both ver_hi and ver_lo cannot be null, it'll crash. */
988 ver_hi = ver_lo = 0x12345678;
989 ret = pSdbGetDatabaseVersion(path, &ver_hi, &ver_lo);
990 ok(ret, "Expected SdbGetDatabaseVersion to succeed\n");
991 if (g_WinVersion >= WINVER_WIN10)
992 {
993 ok(ver_hi == 3, "Expected ver_hi to be 3, was: %d\n", ver_hi);
994 ok(ver_lo == 0, "Expected ver_lo to be 0, was: %d\n", ver_lo);
995 }
996 else
997 {
998 ok(ver_hi == 2, "Expected ver_hi to be 2, was: %d\n", ver_hi);
999 ok(ver_lo == 1, "Expected ver_lo to be 1, was: %d\n", ver_lo);
1000 }
1001
1002 ver_hi = ver_lo = 0x12345678;
1003 ret = pSdbGetDatabaseVersion(NULL, &ver_hi, &ver_lo);
1004 if (g_WinVersion >= WINVER_WIN10)
1005 {
1006 ok(!ret, "Expected SdbGetDatabaseVersion to fail\n");
1007 ok(ver_hi == 0, "Expected ver_hi to be 0, was: 0x%x\n", ver_hi);
1008 ok(ver_lo == 0, "Expected ver_lo to be 0, was: 0x%x\n", ver_lo);
1009 }
1010 else
1011 {
1012 ok(ret, "Expected SdbGetDatabaseVersion to succeed\n");
1013 ok(ver_hi == 0x12345678, "Expected ver_hi to be 0x12345678, was: 0x%x\n", ver_hi);
1014 ok(ver_lo == 0x12345678, "Expected ver_lo to be 0x12345678, was: 0x%x\n", ver_lo);
1015 }
1016
1017 ver_hi = ver_lo = 0x12345678;
1018 ret = pSdbGetDatabaseVersion(path + 1, &ver_hi, &ver_lo);
1019 if (g_WinVersion >= WINVER_WIN10)
1020 {
1021 ok(!ret, "Expected SdbGetDatabaseVersion to fail\n");
1022 ok(ver_hi == 0, "Expected ver_hi to be 0, was: 0x%x\n", ver_hi);
1023 ok(ver_lo == 0, "Expected ver_lo to be 0, was: 0x%x\n", ver_lo);
1024 }
1025 else
1026 {
1027 ok(ret, "Expected SdbGetDatabaseVersion to succeed\n");
1028 ok(ver_hi == 0x12345678, "Expected ver_hi to be 0x12345678, was: 0x%x\n", ver_hi);
1029 ok(ver_lo == 0x12345678, "Expected ver_lo to be 0x12345678, was: 0x%x\n", ver_lo);
1030 }
1031
1032 pdb = pSdbOpenDatabase(path, DOS_PATH);
1033 ok(pdb != NULL, "unexpected NULL handle\n");
1034
1035 root = pSdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
1036 ok(root != TAGID_NULL, "expected to find a root tag\n");
1037 if (root != TAGID_NULL)
1038 {
1039 TAGID tagLayer = pSdbFindFirstTag(pdb, root, TAG_LAYER);
1040 TAGID tagAlt = pSdbFindFirstNamedTag(pdb, root, TAG_LAYER, TAG_NAME, L"TestNewMode");
1041 TAGID tagAlt2 = pSdbFindFirstNamedTag(pdb, root, TAG_LAYER, TAG_NAME, L"TESTNEWMODE");
1042 TAGID tagAlt3 = pSdbFindFirstNamedTag(pdb, root, TAG_LAYER, TAG_NAME, L"testnewmode");
1043 ok_hex(tagLayer, (int)tagAlt);
1044 ok_hex(tagLayer, (int)tagAlt2);
1045 ok_hex(tagLayer, (int)tagAlt3);
1046 check_db_properties(pdb, root);
1047 check_db_layer(pdb, tagLayer);
1048 check_db_exes(pdb, root);
1049 check_db_apphelp(pdb, root);
1050 }
1051
1052 pSdbCloseDatabase(pdb);
1053 DeleteFileA("test_db.sdb");
1054 }
1055
1056 static void test_is_testdb(PDB pdb)
1057 {
1058 if (pdb)
1059 {
1060 GUID guid;
1061 memset(&guid, 0, sizeof(guid));
1062 ok(pSdbGetDatabaseID(pdb, &guid), "expected SdbGetDatabaseID not to fail.\n");
1063 ok(IsEqualGUID(guid, GUID_DATABASE_TEST), "Expected SdbGetDatabaseID to return the test db GUID, was: %s\n", wine_dbgstr_guid(&guid));
1064 }
1065 else
1066 {
1067 skip("Not checking DB GUID, received a null pdb\n");
1068 }
1069 }
1070
1071 static BOOL IsUserAdmin()
1072 {
1073 BOOL Result;
1074 SID_IDENTIFIER_AUTHORITY NtAuthority = { SECURITY_NT_AUTHORITY };
1075 PSID AdministratorsGroup;
1076
1077 Result = AllocateAndInitializeSid(&NtAuthority, 2,
1078 SECURITY_BUILTIN_DOMAIN_RID,
1079 DOMAIN_ALIAS_RID_ADMINS,
1080 0, 0, 0, 0, 0, 0,
1081 &AdministratorsGroup);
1082 if (Result)
1083 {
1084 if (!CheckTokenMembership( NULL, AdministratorsGroup, &Result))
1085 Result = FALSE;
1086 FreeSid(AdministratorsGroup);
1087 }
1088
1089 return Result;
1090 }
1091
1092
1093
1094 template<typename SDBQUERYRESULT_T>
1095 static void check_adwExeFlags(DWORD adwExeFlags_0, SDBQUERYRESULT_T& query, const char* file, int line, int cur)
1096 {
1097 ok_(file, line)(query.adwExeFlags[0] == adwExeFlags_0, "Expected adwExeFlags[0] to be 0x%x, was: 0x%x for %d\n", adwExeFlags_0, query.adwExeFlags[0], cur);
1098 for (size_t n = 1; n < _countof(query.atrExes); ++n)
1099 ok_(file, line)(query.adwExeFlags[n] == 0, "Expected adwExeFlags[%d] to be 0, was: %x for %d\n", n, query.adwExeFlags[0], cur);
1100 }
1101
1102 template<>
1103 void check_adwExeFlags(DWORD, SDBQUERYRESULT_2k3&, const char*, int, int)
1104 {
1105 }
1106
1107
1108 template<typename SDBQUERYRESULT_T>
1109 static void test_mode_generic(const WCHAR* workdir, HSDB hsdb, int cur)
1110 {
1111 WCHAR exename[MAX_PATH], testfile[MAX_PATH];
1112 BOOL ret;
1113 SDBQUERYRESULT_T query;
1114 PDB pdb;
1115 TAGID tagid;
1116 TAGREF trApphelp;
1117 DWORD expect_flags = 0, adwExeFlags_0, exe_count;
1118 UNICODE_STRING exenameNT;
1119
1120 memset(&query, 0xab, sizeof(query));
1121
1122 swprintf(exename, L"%s\\%s", workdir, test_exedata[cur].name);
1123 if (test_exedata[cur].extra_file)
1124 swprintf(testfile, L"%s\\%s", workdir, test_exedata[cur].extra_file);
1125 test_create_exe(exename, 0);
1126
1127 if (test_exedata[cur].extra_file)
1128 {
1129 /* First we try without the file at all. */
1130 DeleteFileW(testfile);
1131 ret = pSdbGetMatchingExe(hsdb, exename, NULL, NULL, 0, (SDBQUERYRESULT_VISTA*)&query);
1132 ok(ret == 0, "SdbGetMatchingExe should have failed for %d.\n", cur);
1133 /* Now re-try with the correct file */
1134 test_create_file(testfile, "aaaa", 4);
1135 }
1136
1137 #if 0
1138 // Results seem to be cached based on filename, until we can invalidate this, do not test the same filename twice!
1139 DeleteFileW(exename);
1140 // skip exports
1141 test_create_exe(exename, 1);
1142 ret = pSdbGetMatchingExe(hsdb, exenameW, NULL, NULL, 0, &query);
1143 ok(ret == 0, "SdbGetMatchingExe should have failed for %d.\n", cur);
1144
1145 DeleteFileW(exename);
1146 test_create_exe(exename, 0);
1147 #endif
1148
1149 if (test_exedata[cur].env_var)
1150 {
1151 SetEnvironmentVariableA("__COMPAT_LAYER", test_exedata[cur].env_var);
1152 }
1153
1154 ret = pSdbGetMatchingExe(hsdb, exename, NULL, NULL, 0, (SDBQUERYRESULT_VISTA*)&query);
1155 ok(ret, "SdbGetMatchingExe should not fail for %d.\n", cur);
1156
1157 exe_count = (test_exedata[cur].env_var == NULL) ? 1 : 0;
1158
1159 ok(query.dwExeCount == exe_count, "Expected dwExeCount to be %d, was %d for %d\n", exe_count, query.dwExeCount, cur);
1160 ok(query.dwLayerCount == test_exedata[cur].dwLayerCount, "Expected dwLayerCount to be %d, was %d for %d\n", test_exedata[cur].dwLayerCount, query.dwLayerCount, cur);
1161 ok(query.dwCustomSDBMap == 1, "Expected dwCustomSDBMap to be 1, was %d for %d\n", query.dwCustomSDBMap, cur);
1162 ok(query.dwLayerFlags == 0, "Expected dwLayerFlags to be 0, was 0x%x for %d\n", query.dwLayerFlags, cur);
1163 trApphelp = (g_WinVersion < WINVER_WIN10) ? 0 : test_exedata[cur].trApphelp;
1164 ok(query.trApphelp == trApphelp, "Expected trApphelp to be 0x%x, was 0x%x for %d\n", trApphelp, query.trApphelp, cur);
1165
1166 if (g_WinVersion < WINVER_WIN7)
1167 expect_flags = 0;
1168 else if (g_WinVersion < WINVER_WIN8)
1169 expect_flags = 1;
1170 else if (g_WinVersion < WINVER_WIN10)
1171 expect_flags = 0x101;
1172 else
1173 {
1174 expect_flags = 0x121; /* for 2 and 3, this becomes 101 when not elevated. */
1175 if ((cur == 2 || cur == 3) && !IsUserAdmin())
1176 expect_flags &= ~0x20;
1177 }
1178
1179 if (test_exedata[cur].env_var)
1180 expect_flags &= ~0x100;
1181
1182 ok(query.dwFlags == expect_flags, "Expected dwFlags to be 0x%x, was 0x%x for %d\n", expect_flags, query.dwFlags, cur);
1183
1184 ok(query.atrExes[0] == test_exedata[cur].atrExes_0, "Expected atrExes[0] to be 0x%x, was: 0x%x for %d\n", test_exedata[cur].atrExes_0, query.atrExes[0], cur);
1185 for (size_t n = 1; n < _countof(query.atrExes); ++n)
1186 ok(query.atrExes[n] == 0, "Expected atrExes[%d] to be 0, was: %x for %d\n", n, query.atrExes[n], cur);
1187
1188 adwExeFlags_0 = (g_WinVersion < WINVER_WIN10) ? 0 : test_exedata[cur].adwExeFlags_0;
1189 check_adwExeFlags(adwExeFlags_0, query, __FILE__, __LINE__, cur);
1190
1191 ok(query.atrLayers[0] == test_exedata[cur].atrLayers_0, "Expected atrLayers[0] to be 0x%x, was: %x for %d\n", test_exedata[cur].atrLayers_0, query.atrLayers[0], cur);
1192 for (size_t n = 1; n < _countof(query.atrLayers); ++n)
1193 ok(query.atrLayers[n] == 0, "Expected atrLayers[%d] to be 0, was: %x for %d\n", n, query.atrLayers[0], cur);
1194
1195 if (g_WinVersion >= WINVER_VISTA)
1196 ok(IsEqualGUID(query.rgGuidDB[0], GUID_DATABASE_TEST), "Expected rgGuidDB[0] to be the test db GUID, was: %s for %d\n", wine_dbgstr_guid(&query.rgGuidDB[0]), cur);
1197 else
1198 ok(IsEqualGUID(query.rgGuidDB[0], GUID_MAIN_DATABASE), "Expected rgGuidDB[0] to be the main db GUID, was: %s for %d\n", wine_dbgstr_guid(&query.rgGuidDB[0]), cur);
1199 for (size_t n = 1; n < _countof(query.rgGuidDB); ++n)
1200 ok(IsEqualGUID(query.rgGuidDB[n], GUID_NULL), "Expected rgGuidDB[%d] to be GUID_NULL, was: %s for %d\n", n, wine_dbgstr_guid(&query.rgGuidDB[n]), cur);
1201
1202 if (query.atrExes[0])
1203 {
1204 pdb = (PDB)0x12345678;
1205 tagid = 0x76543210;
1206 ret = pSdbTagRefToTagID(hsdb, query.atrExes[0], &pdb, &tagid);
1207 ok(ret, "SdbTagRefToTagID failed for %d.\n", cur);
1208 ok(pdb != NULL && pdb != (PDB)0x12345678, "SdbTagRefToTagID failed to return a pdb for %d.\n", cur);
1209 ok(tagid != 0 && tagid != 0x76543210, "SdbTagRefToTagID failed to return a tagid for %d.\n", cur);
1210
1211 if (pdb && pdb != (PDB)0x12345678)
1212 {
1213 TAGREF tr = 0x12345678;
1214 TAG tag = pSdbGetTagFromTagID(pdb, tagid);
1215 test_is_testdb(pdb);
1216 ok(tag == TAG_EXE, "Expected tag to be TAG_EXE, was 0x%x for %d.\n", tag, cur);
1217 match_strw_attr(pdb, tagid, TAG_NAME, test_exedata[cur].name);
1218
1219 /* And back again */
1220 ret = pSdbTagIDToTagRef(hsdb, pdb, tagid, &tr);
1221 ok(ret, "SdbTagIDToTagRef failed for %d.\n", cur);
1222 ok(tr == query.atrExes[0], "Expected tr to be 0x%x, was 0x%x for %d.\n", query.atrExes[0], tr, cur);
1223 }
1224 else
1225 {
1226 skip("Skipping a bunch of tests because of an invalid pointer\n");
1227 }
1228 }
1229
1230 if (test_exedata[cur].atrLayers_0)
1231 {
1232 pdb = (PDB)0x12345678;
1233 tagid = 0x76543210;
1234 ret = pSdbTagRefToTagID(hsdb, query.atrLayers[0], &pdb, &tagid);
1235 ok(ret, "SdbTagRefToTagID failed for %d.\n", cur);
1236 ok(pdb != NULL && pdb != (PDB)0x12345678, "SdbTagRefToTagID failed to return a pdb for %d.\n", cur);
1237 ok(tagid != 0 && tagid != 0x76543210, "SdbTagRefToTagID failed to return a tagid for %d.\n", cur);
1238
1239 if (pdb && pdb != (PDB)0x12345678)
1240 {
1241 TAGREF tr = 0x12345678;
1242 TAG tag = pSdbGetTagFromTagID(pdb, tagid);
1243 test_is_testdb(pdb);
1244 ok(tag == TAG_LAYER, "Expected tag to be TAG_LAYER, was 0x%x for %d.\n", tag, cur);
1245 match_strw_attr(pdb, tagid, TAG_NAME, L"TestNewMode");
1246
1247 /* And back again */
1248 ret = pSdbTagIDToTagRef(hsdb, pdb, tagid, &tr);
1249 ok(ret, "SdbTagIDToTagRef failed for %d.\n", cur);
1250 ok(tr == test_exedata[cur].atrLayers_0, "Expected tr to be 0x%x, was 0x%x for %d.\n", test_exedata[cur].atrLayers_0, tr, cur);
1251 }
1252 else
1253 {
1254 skip("Skipping a bunch of tests because of an invalid pointer\n");
1255 }
1256 }
1257
1258 pdb = (PDB)0x12345678;
1259 tagid = 0x76543210;
1260 ret = pSdbTagRefToTagID(hsdb, 0, &pdb, &tagid);
1261 ok(pdb != NULL && pdb != (PDB)0x12345678, "Expected pdb to be set to a valid pdb, was: %p\n", pdb);
1262 ok(tagid == 0, "Expected tagid to be set to 0, was: 0x%x\n", tagid);
1263
1264
1265
1266 if (RtlDosPathNameToNtPathName_U(exename, &exenameNT, NULL, NULL))
1267 {
1268 ret = pSdbGetMatchingExe(hsdb, exenameNT.Buffer, NULL, NULL, 0, (SDBQUERYRESULT_VISTA*)&query);
1269 if (!ret && g_WinVersion >= WINVER_WIN10)
1270 {
1271 /*
1272 ERROR,AslPathGetLongFileNameLongpath,110,Long path conversion failed 123 [c0000001]
1273 ERROR,AslPathBuildSignatureLongpath,1086,AslPathGetLongFileNameLongpath failed for \??\C:\Users\MARK~1.DEV\AppData\Local\Temp\apphelp_test\test_allow.exe [c0000001]
1274 */
1275 trace("Using DOS path for Win10\n");
1276 ret = pSdbGetMatchingExe(hsdb, exename, NULL, NULL, 0, (SDBQUERYRESULT_VISTA*)&query);
1277 }
1278 ok(ret, "SdbGetMatchingExe should not fail for %d.\n", cur);
1279
1280 RtlFreeUnicodeString(&exenameNT);
1281 }
1282
1283 if (test_exedata[cur].extra_file)
1284 DeleteFileW(testfile);
1285 DeleteFileW(exename);
1286
1287 if (test_exedata[cur].env_var)
1288 {
1289 SetEnvironmentVariableA("__COMPAT_LAYER", NULL);
1290 }
1291 }
1292
1293 template<typename SDBQUERYRESULT_T>
1294 static void test_MatchApplications(void)
1295 {
1296 WCHAR workdir[MAX_PATH], dbpath[MAX_PATH];
1297 BOOL ret;
1298 HSDB hsdb;
1299
1300 ret = GetTempPathW(_countof(workdir), workdir);
1301 ok(ret, "GetTempPathW error: %d\n", GetLastError());
1302 wcscat(workdir, L"apphelp_test");
1303
1304 ret = CreateDirectoryW(workdir, NULL);
1305 ok(ret, "CreateDirectoryW error: %d\n", GetLastError());
1306
1307 /* SdbInitDatabase needs an nt-path */
1308 swprintf(dbpath, L"\\??\\%s\\test.sdb", workdir);
1309
1310 test_create_db(dbpath + 4, g_WinVersion >= WINVER_WIN10);
1311
1312 hsdb = pSdbInitDatabase(HID_DATABASE_FULLPATH, dbpath);
1313
1314 ok(hsdb != NULL, "Expected a valid database handle\n");
1315
1316 if (!hsdb)
1317 {
1318 skip("SdbInitDatabase not implemented?\n");
1319 }
1320 else
1321 {
1322 /* now that our enviroment is setup, let's go ahead and run the actual tests.. */
1323 size_t n;
1324 for (n = 0; n < _countof(test_exedata); ++n)
1325 test_mode_generic<SDBQUERYRESULT_T>(workdir, hsdb, n);
1326 pSdbReleaseDatabase(hsdb);
1327 }
1328
1329 DeleteFileW(dbpath + 4);
1330
1331 ret = RemoveDirectoryW(workdir);
1332 ok(ret, "RemoveDirectoryW error: %d\n", GetLastError());
1333 }
1334
1335 static void test_TagRef(void)
1336 {
1337 WCHAR tmpdir[MAX_PATH], dbpath[MAX_PATH];
1338 BOOL ret;
1339 HSDB hsdb;
1340 PDB pdb;
1341 TAGID db;
1342 DWORD size;
1343 TAGREF tr;
1344
1345 ret = GetTempPathW(_countof(tmpdir), tmpdir);
1346 ok(ret, "GetTempPathA error: %d\n", GetLastError());
1347
1348 /* SdbInitDatabase needs an nt-path */
1349 swprintf(dbpath, L"\\??\\%stest.sdb", tmpdir);
1350
1351 test_create_db(dbpath + 4, g_WinVersion >= WINVER_WIN10);
1352
1353 hsdb = pSdbInitDatabase(HID_DATABASE_FULLPATH, dbpath);
1354
1355 /* HSDB is the only arg that can't be null */
1356 ret = pSdbTagRefToTagID(hsdb, 0, NULL, NULL);
1357 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1358
1359 size = test_get_db_size();
1360
1361 pdb = (PDB)&db;
1362 db = 12345;
1363 ret = pSdbTagRefToTagID(hsdb, size - 1, &pdb, &db);
1364 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1365 ok(pdb != NULL, "Expected a result, got: %p\n", pdb);
1366 ok(db == (size - 1), "Expected %u, got: %u\n", size - 1, db);
1367
1368 /* Convert it back. */
1369 tr = 0x12345678;
1370 ret = pSdbTagIDToTagRef(hsdb, pdb, db, &tr);
1371 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1372 ok(tr == (size - 1), "Expected %u, got: %u\n", size - 1, tr);
1373
1374 pdb = (PDB)&db;
1375 db = 12345;
1376 ret = pSdbTagRefToTagID(hsdb, size, &pdb, &db);
1377 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1378 ok(pdb != NULL, "Expected a result, got: %p\n", pdb);
1379 ok(db == size, "Expected %u, got: %u\n", size, db);
1380
1381 tr = 0x12345678;
1382 ret = pSdbTagIDToTagRef(hsdb, pdb, db, &tr);
1383 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1384 ok(tr == size, "Expected %u, got: %u\n", size, tr);
1385
1386 pdb = (PDB)&db;
1387 db = 12345;
1388 ret = pSdbTagRefToTagID(hsdb, size + 1, &pdb, &db);
1389 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1390 ok(pdb != NULL, "Expected a result, got: %p\n", pdb);
1391 ok(db == (size + 1), "Expected %u, got: %u\n", size + 1, db);
1392
1393 tr = 0x12345678;
1394 ret = pSdbTagIDToTagRef(hsdb, pdb, db, &tr);
1395 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1396 ok(tr == (size + 1), "Expected %u, got: %u\n", (size + 1), tr);
1397
1398 pdb = (PDB)&db;
1399 db = 12345;
1400 ret = pSdbTagRefToTagID(hsdb, 0x0fffffff, &pdb, &db);
1401 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1402 ok(pdb != NULL, "Expected a result, got: %p\n", pdb);
1403 ok(db == 0x0fffffff, "Expected %u, got: %u\n", 0x0fffffff, db);
1404
1405 tr = 0x12345678;
1406 ret = pSdbTagIDToTagRef(hsdb, pdb, db, &tr);
1407 ok(ret == TRUE, "Expected ret to be TRUE, was: %d\n", ret);
1408 ok(tr == 0x0fffffff, "Expected %u, got: %u\n", 0x0fffffff, tr);
1409
1410 pdb = (PDB)&db;
1411 db = 12345;
1412 ret = pSdbTagRefToTagID(hsdb, 0x10000000, &pdb, &db);
1413 ok(ret == FALSE, "Expected ret to be FALSE, was: %d\n", ret);
1414 ok(pdb == NULL, "Expected no result, got: %p\n", pdb);
1415 ok(db == 0, "Expected no result, got: 0x%x\n", db);
1416
1417 tr = 0x12345678;
1418 ret = pSdbTagIDToTagRef(hsdb, pdb, 0x10000000, &tr);
1419 ok(ret == FALSE, "Expected ret to be TRUE, was: %d\n", ret);
1420 ok(tr == 0, "Expected %u, got: %u\n", 0, tr);
1421
1422 pdb = NULL;
1423 db = TAGID_NULL;
1424 ret = pSdbTagRefToTagID(hsdb, TAGID_ROOT, &pdb, NULL);
1425 ok(ret != FALSE, "Expected ret to be TRUE, was: %d\n", ret);
1426 ok(pdb != NULL, "Expected pdb to be valid\n");
1427
1428 if (pdb == NULL)
1429 {
1430 skip("Cannot run tests without pdb\n");
1431 }
1432 else
1433 {
1434 db = pSdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
1435 if (db != TAGID_NULL)
1436 {
1437 TAGID child;
1438 child = pSdbGetFirstChild(pdb, db);
1439 while (child != TAGID_NULL)
1440 {
1441 PDB pdb_res;
1442 TAGID tagid_res;
1443 /* We are using a TAGID as a TAGREF here. */
1444 ret = pSdbTagRefToTagID(hsdb, child, &pdb_res, &tagid_res);
1445 ok(ret, "Expected SdbTagRefToTagID to succeed\n");
1446
1447 /* For simple cases (primary DB) TAGREF == TAGID */
1448 tr = 0x12345678;
1449 ret = pSdbTagIDToTagRef(hsdb, pdb_res, tagid_res, &tr);
1450 ok(ret, "Expected SdbTagIDToTagRef to succeed\n");
1451 ok_hex(tr, (int)tagid_res);
1452
1453 child = pSdbGetNextChild(pdb, db, child);
1454 }
1455 }
1456 else
1457 {
1458 skip("Cannot run tests without valid db tag\n");
1459 }
1460 }
1461
1462 /* Get a tagref for our own layer */
1463 tr = pSdbGetLayerTagRef(hsdb, L"TestNewMode");
1464 ok_hex(tr, 0x18e);
1465
1466 /* We cannot find a tagref from the main database. */
1467 tr = pSdbGetLayerTagRef(hsdb, L"256Color");
1468 ok_hex(tr, 0);
1469
1470 pSdbReleaseDatabase(hsdb);
1471
1472 DeleteFileW(dbpath + 4);
1473 }
1474
1475
1476
1477 static void expect_indexA_imp(const char* text, LONGLONG expected)
1478 {
1479 static WCHAR wide_string[100] = { 0 };
1480 LONGLONG result;
1481 MultiByteToWideChar(CP_ACP, 0, text, -1, wide_string, 100);
1482
1483 result = pSdbMakeIndexKeyFromString(wide_string);
1484 winetest_ok(result == expected, "Expected %s to result in %s, was: %s\n", text, wine_dbgstr_longlong(expected), wine_dbgstr_longlong(result));
1485 }
1486
1487 #define expect_indexA (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_indexA_imp
1488
1489 static void test_IndexKeyFromString(void)
1490 {
1491 #if 0
1492 static WCHAR tmp[] = { 0xabba, 0xbcde, 0x2020, 0x20, 0x4444, 0 };
1493 static WCHAR tmp2[] = { 0xabba, 0xbcde, 0x20, 0x4444, 0 };
1494 static WCHAR tmp3[] = { 0x20, 0xbcde, 0x4041, 0x4444, 0 };
1495 static WCHAR tmp4[] = { 0x20, 0xbcde, 0x4041, 0x4444, 0x4444, 0 };
1496 static WCHAR tmp5[] = { 0x2020, 0xbcde, 0x4041, 0x4444, 0x4444, 0 };
1497 static WCHAR tmp6 [] = { 0x20, 0xbcde, 0x4041, 0x4444, 0x4444, 0x4444, 0};
1498 static WCHAR tmp7 [] = { 0xbcde, 0x4041, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0};
1499 static WCHAR tmp8 [] = { 0xbc00, 0x4041, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0};
1500 #endif
1501
1502 #if 0
1503 /* This crashes. */
1504 pSdbMakeIndexKeyFromString(NULL);
1505 #endif
1506
1507 expect_indexA("", 0x0000000000000000);
1508 expect_indexA("a", 0x4100000000000000);
1509 expect_indexA("aa", 0x4141000000000000);
1510 expect_indexA("aaa", 0x4141410000000000);
1511 expect_indexA("aaaa", 0x4141414100000000);
1512 expect_indexA("aaaaa", 0x4141414141000000);
1513 expect_indexA("aaaaaa", 0x4141414141410000);
1514 expect_indexA("aaaaaaa", 0x4141414141414100);
1515 expect_indexA("aaaaaaaa", 0x4141414141414141);
1516 expect_indexA("aaa aaaaa", 0x4141412041414141);
1517 /* Does not change */
1518 expect_indexA("aaaaaaaaa", 0x4141414141414141);
1519 expect_indexA("aaaaaaaab", 0x4141414141414141);
1520 expect_indexA("aaaaaaaac", 0x4141414141414141);
1521 expect_indexA("aaaaaaaaF", 0x4141414141414141);
1522 /* Upcase */
1523 expect_indexA("AAAAAAAA", 0x4141414141414141);
1524 expect_indexA("ABABABAB", 0x4142414241424142);
1525 expect_indexA("ABABABABZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ", 0x4142414241424142);
1526
1527 #if 0
1528 /* These fail, but is that because the codepoints are too weird, or because the func is not correct? */
1529 result = pSdbMakeIndexKeyFromString(tmp);
1530 ok(result == 0xbaabdebc20200000, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp),
1531 wine_dbgstr_longlong(0xbaabdebc20200000), wine_dbgstr_longlong(result));
1532
1533 result = pSdbMakeIndexKeyFromString(tmp2);
1534 ok(result == 0xbaabdebc00000000, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp2),
1535 wine_dbgstr_longlong(0xbaabdebc00000000), wine_dbgstr_longlong(result));
1536
1537 result = pSdbMakeIndexKeyFromString(tmp3);
1538 ok(result == 0x20debc4140000000, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp3),
1539 wine_dbgstr_longlong(0x20debc4140000000), wine_dbgstr_longlong(result));
1540
1541 result = pSdbMakeIndexKeyFromString(tmp4);
1542 ok(result == 0x20debc4140000000, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp4),
1543 wine_dbgstr_longlong(0x20debc4140000000), wine_dbgstr_longlong(result));
1544
1545 result = pSdbMakeIndexKeyFromString(tmp5);
1546 ok(result == 0x2020debc41400000, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp5),
1547 wine_dbgstr_longlong(0x2020debc41400000), wine_dbgstr_longlong(result));
1548
1549 result = pSdbMakeIndexKeyFromString(tmp6);
1550 ok(result == 0x20debc4140444400, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp6),
1551 wine_dbgstr_longlong(0x20debc4140444400), wine_dbgstr_longlong(result));
1552
1553 result = pSdbMakeIndexKeyFromString(tmp7);
1554 ok(result == 0xdebc414044444444, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp7),
1555 wine_dbgstr_longlong(0xdebc414044444444), wine_dbgstr_longlong(result));
1556
1557 result = pSdbMakeIndexKeyFromString(tmp8);
1558 ok(result == 0xbc414044444444, "Expected %s to result in %s, was: %s\n", wine_dbgstr_w(tmp8),
1559 wine_dbgstr_longlong(0xbc414044444444), wine_dbgstr_longlong(result));
1560 #endif
1561 }
1562
1563 static int validate_SDBQUERYRESULT_size()
1564 {
1565 unsigned char buffer[SDBQUERYRESULT_EXPECTED_SIZE_VISTA * 2];
1566 WCHAR path[MAX_PATH];
1567 size_t n;
1568
1569 memset(buffer, 0xab, sizeof(buffer));
1570
1571 GetModuleFileNameW(NULL, path, MAX_PATH);
1572 pSdbGetMatchingExe(NULL, path, NULL, NULL, 0, (SDBQUERYRESULT_VISTA*)buffer);
1573 if (buffer[0] == 0xab)
1574 {
1575 trace("SdbGetMatchingExe didnt do anything, cannot determine SDBQUERYRESULT size\n");
1576 return 0;
1577 }
1578
1579 if (buffer[SDBQUERYRESULT_EXPECTED_SIZE_2k3] == 0xab && buffer[SDBQUERYRESULT_EXPECTED_SIZE_2k3-1] != 0xab)
1580 {
1581 return 1;
1582 }
1583
1584 if (buffer[SDBQUERYRESULT_EXPECTED_SIZE_VISTA] == 0xab && buffer[SDBQUERYRESULT_EXPECTED_SIZE_VISTA-1] != 0xab)
1585 {
1586 return 2;
1587 }
1588
1589 for (n = 0; n < _countof(buffer); ++n)
1590 {
1591 if (buffer[n] != 0xab)
1592 {
1593 trace("Unknown size: %i\n", n);
1594 break;
1595 }
1596 }
1597
1598 return 0;
1599 }
1600
1601
1602 START_TEST(db)
1603 {
1604 //SetEnvironmentVariable("SHIM_DEBUG_LEVEL", "4");
1605 //SetEnvironmentVariable("SHIMENG_DEBUG_LEVEL", "4");
1606 //SetEnvironmentVariable("DEBUGCHANNEL", "+apphelp");
1607
1608 silence_debug_output();
1609 hdll = LoadLibraryA("apphelp.dll");
1610
1611 /* We detect the apphelp version that is loaded, instead of the os we are running on.
1612 This allows for easier testing multiple versions of the dll */
1613 g_WinVersion = get_module_version(hdll);
1614 trace("Apphelp version: 0x%x\n", g_WinVersion);
1615
1616 *(void**)&pSdbTagToString = (void *)GetProcAddress(hdll, "SdbTagToString");
1617 *(void**)&pSdbOpenDatabase = (void *)GetProcAddress(hdll, "SdbOpenDatabase");
1618 *(void**)&pSdbCreateDatabase = (void *)GetProcAddress(hdll, "SdbCreateDatabase");
1619 *(void**)&pSdbGetDatabaseVersion = (void *)GetProcAddress(hdll, "SdbGetDatabaseVersion");
1620 *(void**)&pSdbCloseDatabase = (void *)GetProcAddress(hdll, "SdbCloseDatabase");
1621 *(void**)&pSdbCloseDatabaseWrite = (void *)GetProcAddress(hdll, "SdbCloseDatabaseWrite");
1622 *(void**)&pSdbGetTagFromTagID = (void *)GetProcAddress(hdll, "SdbGetTagFromTagID");
1623 *(void**)&pSdbWriteNULLTag = (void *)GetProcAddress(hdll, "SdbWriteNULLTag");
1624 *(void**)&pSdbWriteWORDTag = (void *)GetProcAddress(hdll, "SdbWriteWORDTag");
1625 *(void**)&pSdbWriteDWORDTag = (void *)GetProcAddress(hdll, "SdbWriteDWORDTag");
1626 *(void**)&pSdbWriteQWORDTag = (void *)GetProcAddress(hdll, "SdbWriteQWORDTag");
1627 *(void**)&pSdbWriteBinaryTagFromFile = (void *)GetProcAddress(hdll, "SdbWriteBinaryTagFromFile");
1628 *(void**)&pSdbWriteStringTag = (void *)GetProcAddress(hdll, "SdbWriteStringTag");
1629 *(void**)&pSdbWriteStringRefTag = (void *)GetProcAddress(hdll, "SdbWriteStringRefTag");
1630 *(void**)&pSdbBeginWriteListTag = (void *)GetProcAddress(hdll, "SdbBeginWriteListTag");
1631 *(void**)&pSdbEndWriteListTag = (void *)GetProcAddress(hdll, "SdbEndWriteListTag");
1632 *(void**)&pSdbFindFirstTag = (void *)GetProcAddress(hdll, "SdbFindFirstTag");
1633 *(void**)&pSdbFindNextTag = (void *)GetProcAddress(hdll, "SdbFindNextTag");
1634 *(void**)&pSdbFindFirstNamedTag = (void *)GetProcAddress(hdll, "SdbFindFirstNamedTag");
1635 *(void**)&pSdbReadWORDTag = (void *)GetProcAddress(hdll, "SdbReadWORDTag");
1636 *(void**)&pSdbReadDWORDTag = (void *)GetProcAddress(hdll, "SdbReadDWORDTag");
1637 *(void**)&pSdbReadQWORDTag = (void *)GetProcAddress(hdll, "SdbReadQWORDTag");
1638 *(void**)&pSdbReadBinaryTag = (void *)GetProcAddress(hdll, "SdbReadBinaryTag");
1639 *(void**)&pSdbReadStringTag = (void *)GetProcAddress(hdll, "SdbReadStringTag");
1640 *(void**)&pSdbGetTagDataSize = (void *)GetProcAddress(hdll, "SdbGetTagDataSize");
1641 *(void**)&pSdbGetBinaryTagData = (void *)GetProcAddress(hdll, "SdbGetBinaryTagData");
1642 *(void**)&pSdbGetStringTagPtr = (void *)GetProcAddress(hdll, "SdbGetStringTagPtr");
1643 *(void**)&pSdbGetFirstChild = (void *)GetProcAddress(hdll, "SdbGetFirstChild");
1644 *(void**)&pSdbGetNextChild = (void *)GetProcAddress(hdll, "SdbGetNextChild");
1645 *(void**)&pSdbGetDatabaseID = (void *)GetProcAddress(hdll, "SdbGetDatabaseID");
1646 *(void**)&pSdbGUIDToString = (void *)GetProcAddress(hdll, "SdbGUIDToString");
1647 *(void**)&pSdbInitDatabase = (void *)GetProcAddress(hdll, "SdbInitDatabase");
1648 *(void**)&pSdbReleaseDatabase = (void *)GetProcAddress(hdll, "SdbReleaseDatabase");
1649 *(void**)&pSdbGetMatchingExe = (void *)GetProcAddress(hdll, "SdbGetMatchingExe");
1650 *(void**)&pSdbTagRefToTagID = (void *)GetProcAddress(hdll, "SdbTagRefToTagID");
1651 *(void**)&pSdbTagIDToTagRef = (void *)GetProcAddress(hdll, "SdbTagIDToTagRef");
1652 *(void**)&pSdbMakeIndexKeyFromString = (void *)GetProcAddress(hdll, "SdbMakeIndexKeyFromString");
1653 *(void**)&pSdbGetLayerTagRef = (void *)GetProcAddress(hdll, "SdbGetLayerTagRef");
1654
1655 test_Sdb();
1656 test_write_ex();
1657 test_stringtable();
1658 test_CheckDatabaseManually();
1659 switch (validate_SDBQUERYRESULT_size())
1660 {
1661 case 1:
1662 test_MatchApplications<SDBQUERYRESULT_2k3>();
1663 break;
1664 case 2:
1665 test_MatchApplications<SDBQUERYRESULT_VISTA>();
1666 break;
1667 default:
1668 skip("Skipping tests with SDBQUERYRESULT due to a wrong size reported\n");
1669 break;
1670 }
1671 test_TagRef();
1672 skip("test_SecondaryDB()\n");
1673 test_IndexKeyFromString();
1674 }