1 /*
2 * Copyright (C) 2004 Stefan Leichter
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20 #include <stdio.h>
21 #include <assert.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "winver.h"
27 #include "wine/test.h"
28
29 #define MY_LAST_ERROR ((DWORD)-1)
30 #define EXPECT_BAD_PATH__NOT_FOUND \
31 ok( (ERROR_PATH_NOT_FOUND == GetLastError()) || \
32 (ERROR_RESOURCE_DATA_NOT_FOUND == GetLastError()) || \
33 (ERROR_FILE_NOT_FOUND == GetLastError()) || \
34 (ERROR_BAD_PATHNAME == GetLastError()) || \
35 (ERROR_SUCCESS == GetLastError()), \
36 "Last error wrong! ERROR_RESOURCE_DATA_NOT_FOUND/ERROR_BAD_PATHNAME (98)/" \
37 "ERROR_PATH_NOT_FOUND (NT4)/ERROR_FILE_NOT_FOUND (2k3) " \
38 "ERROR_SUCCESS (2k) expected, got %u\n", GetLastError());
39 #define EXPECT_INVALID__NOT_FOUND \
40 ok( (ERROR_PATH_NOT_FOUND == GetLastError()) || \
41 (ERROR_RESOURCE_DATA_NOT_FOUND == GetLastError()) || \
42 (ERROR_FILE_NOT_FOUND == GetLastError()) || \
43 (ERROR_INVALID_PARAMETER == GetLastError()) || \
44 (ERROR_SUCCESS == GetLastError()), \
45 "Last error wrong! ERROR_RESOURCE_DATA_NOT_FOUND/ERROR_INVALID_PARAMETER (98)/" \
46 "ERROR_PATH_NOT_FOUND (NT4)/ERROR_FILE_NOT_FOUND (2k3) " \
47 "ERROR_SUCCESS (2k) expected, got %u\n", GetLastError());
48
49 static void create_file(const CHAR *name)
50 {
51 HANDLE file;
52 DWORD written;
53
54 file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
55 ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
56 WriteFile(file, name, strlen(name), &written, NULL);
57 WriteFile(file, "\n", strlen("\n"), &written, NULL);
58 CloseHandle(file);
59 }
60
61 static void test_info_size(void)
62 { DWORD hdl, retval;
63 char mypath[MAX_PATH] = "";
64
65 SetLastError(MY_LAST_ERROR);
66 retval = GetFileVersionInfoSizeA( NULL, NULL);
67 ok( !retval,
68 "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n",
69 retval);
70 EXPECT_INVALID__NOT_FOUND;
71
72 hdl = 0x55555555;
73 SetLastError(MY_LAST_ERROR);
74 retval = GetFileVersionInfoSizeA( NULL, &hdl);
75 ok( !retval,
76 "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n",
77 retval);
78 EXPECT_INVALID__NOT_FOUND;
79 ok( hdl == 0L,
80 "Handle wrong! 0L expected, got 0x%08x\n", hdl);
81
82 SetLastError(MY_LAST_ERROR);
83 retval = GetFileVersionInfoSizeA( "", NULL);
84 ok( !retval,
85 "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n",
86 retval);
87 EXPECT_BAD_PATH__NOT_FOUND;
88
89 hdl = 0x55555555;
90 SetLastError(MY_LAST_ERROR);
91 retval = GetFileVersionInfoSizeA( "", &hdl);
92 ok( !retval,
93 "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n",
94 retval);
95 EXPECT_BAD_PATH__NOT_FOUND;
96 ok( hdl == 0L,
97 "Handle wrong! 0L expected, got 0x%08x\n", hdl);
98
99 SetLastError(MY_LAST_ERROR);
100 retval = GetFileVersionInfoSizeA( "kernel32.dll", NULL);
101 ok( retval,
102 "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n",
103 retval);
104 ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()),
105 "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n",
106 MY_LAST_ERROR, GetLastError());
107
108 hdl = 0x55555555;
109 SetLastError(MY_LAST_ERROR);
110 retval = GetFileVersionInfoSizeA( "kernel32.dll", &hdl);
111 ok( retval,
112 "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n",
113 retval);
114 ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()),
115 "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n",
116 MY_LAST_ERROR, GetLastError());
117 ok( hdl == 0L,
118 "Handle wrong! 0L expected, got 0x%08x\n", hdl);
119
120 SetLastError(MY_LAST_ERROR);
121 retval = GetFileVersionInfoSizeA( "notexist.dll", NULL);
122 ok( !retval,
123 "GetFileVersionInfoSizeA result wrong! 0L expected, got 0x%08x\n",
124 retval);
125 ok( (ERROR_FILE_NOT_FOUND == GetLastError()) ||
126 (ERROR_RESOURCE_DATA_NOT_FOUND == GetLastError()) ||
127 (MY_LAST_ERROR == GetLastError()) ||
128 (ERROR_SUCCESS == GetLastError()), /* win2k */
129 "Last error wrong! ERROR_FILE_NOT_FOUND/ERROR_RESOURCE_DATA_NOT_FOUND "
130 "(XP)/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError());
131
132 /* test a currently loaded executable */
133 if(GetModuleFileNameA(NULL, mypath, MAX_PATH)) {
134 hdl = 0x55555555;
135 SetLastError(MY_LAST_ERROR);
136 retval = GetFileVersionInfoSizeA( mypath, &hdl);
137 ok( retval,
138 "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n",
139 retval);
140 ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()),
141 "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n",
142 MY_LAST_ERROR, GetLastError());
143 ok( hdl == 0L,
144 "Handle wrong! 0L expected, got 0x%08x\n", hdl);
145 }
146 else
147 trace("skipping GetModuleFileNameA(NULL,..) failed\n");
148
149 /* test a not loaded executable */
150 if(GetSystemDirectoryA(mypath, MAX_PATH)) {
151 lstrcatA(mypath, "\\regsvr32.exe");
152
153 if(INVALID_FILE_ATTRIBUTES == GetFileAttributesA(mypath))
154 trace("GetFileAttributesA(%s) failed\n", mypath);
155 else {
156 hdl = 0x55555555;
157 SetLastError(MY_LAST_ERROR);
158 retval = GetFileVersionInfoSizeA( mypath, &hdl);
159 ok( retval,
160 "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n",
161 retval);
162 ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()),
163 "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n",
164 MY_LAST_ERROR, GetLastError());
165 ok( hdl == 0L,
166 "Handle wrong! 0L expected, got 0x%08x\n", hdl);
167 }
168 }
169 else
170 trace("skipping GetSystemDirectoryA(mypath,..) failed\n");
171
172 create_file("test.txt");
173
174 /* no version info */
175 SetLastError(0xdeadbeef);
176 hdl = 0xcafe;
177 retval = GetFileVersionInfoSizeA("test.txt", &hdl);
178 ok(retval == 0, "Expected 0, got %d\n", retval);
179 ok(hdl == 0, "Expected 0, got %d\n", hdl);
180 ok(GetLastError() == ERROR_RESOURCE_DATA_NOT_FOUND ||
181 GetLastError() == ERROR_SUCCESS, /* win2k */
182 "Expected ERROR_RESOURCE_DATA_NOT_FOUND, got %d\n", GetLastError());
183
184 DeleteFileA("test.txt");
185 }
186
187 static void VersionDwordLong2String(DWORDLONG Version, LPSTR lpszVerString)
188 {
189 WORD a, b, c, d;
190
191 a = (WORD)(Version >> 48);
192 b = (WORD)((Version >> 32) & 0xffff);
193 c = (WORD)((Version >> 16) & 0xffff);
194 d = (WORD)(Version & 0xffff);
195
196 sprintf(lpszVerString, "%d.%d.%d.%d", a, b, c, d);
197
198 return;
199 }
200
201 static void test_info(void)
202 {
203 DWORD hdl, retval;
204 PVOID pVersionInfo = NULL;
205 BOOL boolret;
206 VS_FIXEDFILEINFO *pFixedVersionInfo;
207 UINT uiLength;
208 char VersionString[MAX_PATH];
209 static CHAR backslash[] = "\\";
210 DWORDLONG dwlVersion;
211
212 hdl = 0x55555555;
213 SetLastError(MY_LAST_ERROR);
214 retval = GetFileVersionInfoSizeA( "kernel32.dll", &hdl);
215 ok( retval,
216 "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n",
217 retval);
218 ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()),
219 "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n",
220 MY_LAST_ERROR, GetLastError());
221 ok( hdl == 0L,
222 "Handle wrong! 0L expected, got 0x%08x\n", hdl);
223
224 if ( retval == 0 || hdl != 0)
225 return;
226
227 pVersionInfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retval );
228 ok(pVersionInfo != 0, "HeapAlloc failed\n" );
229 if (pVersionInfo == 0)
230 return;
231
232 if (0)
233 {
234 /* this test crashes on WinNT4
235 */
236 boolret = GetFileVersionInfoA( "kernel32.dll", 0, retval, 0);
237 ok (!boolret, "GetFileVersionInfoA should have failed: GetLastError = %u\n", GetLastError());
238 ok ((GetLastError() == ERROR_INVALID_DATA) || (GetLastError() == ERROR_BAD_PATHNAME) ||
239 (GetLastError() == NO_ERROR),
240 "Last error wrong! ERROR_INVALID_DATA/ERROR_BAD_PATHNAME (ME)/"
241 "NO_ERROR (95) expected, got %u\n",
242 GetLastError());
243 }
244
245 boolret = GetFileVersionInfoA( "kernel32.dll", 0, retval, pVersionInfo );
246 ok (boolret, "GetFileVersionInfoA failed: GetLastError = %u\n", GetLastError());
247 if (!boolret)
248 goto cleanup;
249
250 boolret = VerQueryValueA( pVersionInfo, NULL, (LPVOID *)&pFixedVersionInfo, &uiLength );
251 ok (boolret || GetLastError() == NO_ERROR /* Win98 */,
252 "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
253
254 boolret = VerQueryValueA( pVersionInfo, "", (LPVOID *)&pFixedVersionInfo, &uiLength );
255 ok (boolret, "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
256
257 boolret = VerQueryValueA( pVersionInfo, backslash, (LPVOID *)&pFixedVersionInfo, &uiLength );
258 ok (boolret, "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
259 if (!boolret)
260 goto cleanup;
261
262 dwlVersion = (((DWORDLONG)pFixedVersionInfo->dwFileVersionMS) << 32) +
263 pFixedVersionInfo->dwFileVersionLS;
264
265 VersionDwordLong2String(dwlVersion, VersionString);
266
267 trace("kernel32.dll version: %s\n", VersionString);
268
269 if (0)
270 {
271 /* this test crashes on WinNT4
272 */
273 boolret = VerQueryValueA( pVersionInfo, backslash, (LPVOID *)&pFixedVersionInfo, 0);
274 ok (boolret, "VerQueryValue failed: GetLastError = %u\n", GetLastError());
275 }
276
277 cleanup:
278 HeapFree( GetProcessHeap(), 0, pVersionInfo);
279 }
280
281 static void test_32bit_win(void)
282 {
283 DWORD hdlA, retvalA;
284 DWORD hdlW, retvalW = 0;
285 BOOL retA,retW;
286 PVOID pVersionInfoA = NULL;
287 PVOID pVersionInfoW = NULL;
288 char *pBufA;
289 WCHAR *pBufW;
290 UINT uiLengthA, uiLengthW;
291 char mypathA[MAX_PATH];
292 WCHAR mypathW[MAX_PATH];
293 char rootA[] = "\\";
294 WCHAR rootW[] = { '\\', 0 };
295 WCHAR emptyW[] = { 0 };
296 char varfileinfoA[] = "\\VarFileInfo\\Translation";
297 WCHAR varfileinfoW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o',
298 '\\','T','r','a','n','s','l','a','t','i','o','n', 0 };
299 char WineVarFileInfoA[] = { 0x09, 0x04, 0xE4, 0x04 };
300 char FileDescriptionA[] = "\\StringFileInfo\\040904E4\\FileDescription";
301 WCHAR FileDescriptionW[] = { '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o',
302 '\\','','4','','9','','4','E','4',
303 '\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n', 0 };
304 char WineFileDescriptionA[] = "FileDescription";
305 WCHAR WineFileDescriptionW[] = { 'F','i','l','e','D','e','s','c','r','i','p','t','i','o','n', 0 };
306 BOOL is_unicode_enabled = TRUE;
307
308 /* A copy from dlls/version/info.c */
309 typedef struct
310 {
311 WORD wLength;
312 WORD wValueLength;
313 WORD wType;
314 WCHAR szKey[1];
315 #if 0 /* variable length structure */
316 /* DWORD aligned */
317 BYTE Value[];
318 /* DWORD aligned */
319 VS_VERSION_INFO_STRUCT32 Children[];
320 #endif
321 } VS_VERSION_INFO_STRUCT32;
322
323 /* If we call GetFileVersionInfoA on a system that supports Unicode, NT/W2K/XP/W2K3 (by default) and Wine,
324 * the versioninfo will contain Unicode strings.
325 * Part of the test is to call both the A and W versions, which should have the same Version Information
326 * for some requests, on systems that support both calls.
327 */
328
329 /* First get the versioninfo via the W versions */
330 SetLastError(0xdeadbeef);
331 GetModuleFileNameW(NULL, mypathW, MAX_PATH);
332 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
333 {
334 win_skip("GetModuleFileNameW not existing on this platform, skipping comparison between A- and W-calls\n");
335 is_unicode_enabled = FALSE;
336 }
337
338 if (is_unicode_enabled)
339 {
340 retvalW = GetFileVersionInfoSizeW( mypathW, &hdlW);
341 pVersionInfoW = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retvalW );
342 retW = GetFileVersionInfoW( mypathW, 0, retvalW, pVersionInfoW );
343 ok(retW, "GetFileVersionInfo failed: GetLastError = %u\n", GetLastError());
344 }
345
346 GetModuleFileNameA(NULL, mypathA, MAX_PATH);
347 retvalA = GetFileVersionInfoSizeA( mypathA, &hdlA);
348 pVersionInfoA = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retvalA );
349 retA = GetFileVersionInfoA( mypathA, 0, retvalA, pVersionInfoA );
350 ok(retA, "GetFileVersionInfo failed: GetLastError = %u\n", GetLastError());
351
352 if (is_unicode_enabled)
353 {
354 ok( retvalA == retvalW, "The size of the struct should be the same for both A/W calls, it is (%d) vs. (%d)\n",
355 retvalA, retvalW);
356 ok( !memcmp(pVersionInfoA, pVersionInfoW, retvalA), "Both structs should be the same, they aren't\n");
357 }
358
359 /* The structs on Windows are bigger than just the struct for the basic information. The total struct
360 * contains also an empty part, which is used for converted strings. The converted strings are a result
361 * of calling VerQueryValueA on a 32bit resource and calling VerQueryValueW on a 16bit resource.
362 * The first WORD of the structure (wLength) shows the size of the base struct. The total struct size depends
363 * on the Windows version:
364 *
365 * 16bits resource (numbers are from a sample app):
366 *
367 * Windows Version Retrieved with A/W wLength StructSize
368 * ====================================================================================
369 * Win98 A 0x01B4 (436) 436
370 * NT4 A/W 0x01B4 (436) 2048 ???
371 * W2K/XP/W2K3 A/W 0x01B4 (436) 1536 which is (436 - sizeof(VS_FIXEDFILEINFO)) * 4
372 *
373 * 32bits resource (numbers are from this test executable version_crosstest.exe):
374 * Windows Version Retrieved with A/W wLength StructSize
375 * =============================================================
376 * Win98 A 0x01E0 (480) 848 (structure data doesn't seem correct)
377 * NT4 A/W 0x0350 (848) 1272 (848 * 1.5)
378 * W2K/XP/W2K3 A/W 0x0350 (848) 1700 which is (848 * 2) + 4
379 *
380 * Wine will follow the implementation (eventually) of W2K/XP/W2K3
381 */
382
383 /* Now some tests for the above (only if we are unicode enabled) */
384
385 if (is_unicode_enabled)
386 {
387 VS_VERSION_INFO_STRUCT32 *vvis = pVersionInfoW;
388 ok ( retvalW == ((vvis->wLength * 2) + 4) || retvalW == (vvis->wLength * 1.5),
389 "Structure is not of the correct size\n");
390 }
391
392 /* Although the 32bit resource structures contain Unicode strings, VerQueryValueA will always return normal strings,
393 * VerQueryValueW will always return Unicode ones. (That means everything returned for StringFileInfo requests).
394 */
395
396 /* Get the VS_FIXEDFILEINFO information, this must be the same for both A- and W-Calls */
397
398 retA = VerQueryValueA( pVersionInfoA, rootA, (LPVOID *)&pBufA, &uiLengthA );
399 ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
400 ok ( uiLengthA == sizeof(VS_FIXEDFILEINFO), "Size (%d) doesn't match the size of the VS_FIXEDFILEINFO struct\n", uiLengthA);
401
402 if (is_unicode_enabled)
403 {
404 if(0)
405 { /* This causes Vista and w2k8 to crash */
406 retW = VerQueryValueW( pVersionInfoW, NULL, (LPVOID *)&pBufW, &uiLengthW );
407 ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError());
408 }
409
410 retW = VerQueryValueW( pVersionInfoW, emptyW, (LPVOID *)&pBufW, &uiLengthW );
411 ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError());
412
413 retW = VerQueryValueW( pVersionInfoW, rootW, (LPVOID *)&pBufW, &uiLengthW );
414 ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError());
415 ok ( uiLengthA == sizeof(VS_FIXEDFILEINFO), "Size (%d) doesn't match the size of the VS_FIXEDFILEINFO struct\n", uiLengthA);
416
417 ok( uiLengthA == uiLengthW, "The size of VS_FIXEDFILEINFO should be the same for both A/W calls, it is (%d) vs. (%d)\n",
418 uiLengthA, uiLengthW);
419 ok( !memcmp(pBufA, pBufW, uiLengthA), "Both values should be the same, they aren't\n");
420 }
421
422 /* Get some VarFileInfo information, this must be the same for both A- and W-Calls */
423
424 retA = VerQueryValueA( pVersionInfoA, varfileinfoA, (LPVOID *)&pBufA, &uiLengthA );
425 ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
426 ok( !memcmp(pBufA, WineVarFileInfoA, uiLengthA), "The VarFileInfo should have matched 0904e404 (non case sensitive)\n");
427
428 if (is_unicode_enabled)
429 {
430 retW = VerQueryValueW( pVersionInfoW, varfileinfoW, (LPVOID *)&pBufW, &uiLengthW );
431 ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError());
432 ok( uiLengthA == uiLengthW, "The size of the VarFileInfo information should be the same for both A/W calls, it is (%d) vs. (%d)\n",
433 uiLengthA, uiLengthW);
434 ok( !memcmp(pBufA, pBufW, uiLengthA), "Both values should be the same, they aren't\n");
435 }
436
437 /* Get some StringFileInfo information, this will be ANSI for A-Calls and Unicode for W-Calls */
438
439 retA = VerQueryValueA( pVersionInfoA, FileDescriptionA, (LPVOID *)&pBufA, &uiLengthA );
440 ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
441 ok( !lstrcmpA(WineFileDescriptionA, pBufA), "expected '%s' got '%s'\n",
442 WineFileDescriptionA, pBufA);
443
444 /* Test a second time */
445 retA = VerQueryValueA( pVersionInfoA, FileDescriptionA, (LPVOID *)&pBufA, &uiLengthA );
446 ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError());
447 ok( !lstrcmpA(WineFileDescriptionA, pBufA), "expected '%s' got '%s'\n",
448 WineFileDescriptionA, pBufA);
449
450 if (is_unicode_enabled)
451 {
452 retW = VerQueryValueW( pVersionInfoW, FileDescriptionW, (LPVOID *)&pBufW, &uiLengthW );
453 ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError());
454 ok( !lstrcmpW(WineFileDescriptionW, pBufW), "FileDescription should have been '%s'\n", WineFileDescriptionA);
455 }
456
457 HeapFree( GetProcessHeap(), 0, pVersionInfoA);
458 if (is_unicode_enabled)
459 HeapFree( GetProcessHeap(), 0, pVersionInfoW);
460 }
461
462 static void test_VerQueryValue(void)
463 {
464 static const char * const value_name[] = {
465 "Product", "CompanyName", "FileDescription", "Internal",
466 "ProductVersion", "InternalName", "File", "LegalCopyright",
467 "FileVersion", "Legal", "OriginalFilename", "ProductName",
468 "Company", "Original" };
469 char *ver, *p;
470 UINT len, ret, translation, i;
471 char buf[MAX_PATH];
472
473 ret = GetModuleFileName(NULL, buf, sizeof(buf));
474 assert(ret);
475
476 SetLastError(0xdeadbeef);
477 len = GetFileVersionInfoSize(buf, NULL);
478 ok(len, "GetFileVersionInfoSize(%s) error %u\n", buf, GetLastError());
479
480 ver = HeapAlloc(GetProcessHeap(), 0, len);
481 assert(ver);
482
483 SetLastError(0xdeadbeef);
484 ret = GetFileVersionInfo(buf, 0, len, ver);
485 ok(ret, "GetFileVersionInfo error %u\n", GetLastError());
486
487 p = (char *)0xdeadbeef;
488 len = 0xdeadbeef;
489 SetLastError(0xdeadbeef);
490 ret = VerQueryValue(ver, "\\VarFileInfo\\Translation", (LPVOID*)&p, &len);
491 ok(ret, "VerQueryValue error %u\n", GetLastError());
492 ok(len == 4, "VerQueryValue returned %u, expected 4\n", len);
493
494 translation = *(UINT *)p;
495 translation = MAKELONG(HIWORD(translation), LOWORD(translation));
496
497 p = (char *)0xdeadbeef;
498 len = 0xdeadbeef;
499 SetLastError(0xdeadbeef);
500 ret = VerQueryValue(ver, "String", (LPVOID*)&p, &len);
501 ok(!ret, "VerQueryValue should fail\n");
502 ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND ||
503 GetLastError() == 0xdeadbeef /* NT4, W2K */,
504 "VerQueryValue returned %u\n", GetLastError());
505 ok(p == (char *)0xdeadbeef, "expected 0xdeadbeef got %p\n", p);
506 ok(len == 0, "expected 0 got %x\n", len);
507
508 p = (char *)0xdeadbeef;
509 len = 0xdeadbeef;
510 SetLastError(0xdeadbeef);
511 ret = VerQueryValue(ver, "StringFileInfo", (LPVOID*)&p, &len);
512 ok(ret, "VerQueryValue error %u\n", GetLastError());
513 todo_wine ok(len == 0, "VerQueryValue returned %u, expected 0\n", len);
514 ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n");
515
516 p = (char *)0xdeadbeef;
517 len = 0xdeadbeef;
518 SetLastError(0xdeadbeef);
519 ret = VerQueryValue(ver, "\\StringFileInfo", (LPVOID*)&p, &len);
520 ok(ret, "VerQueryValue error %u\n", GetLastError());
521 todo_wine ok(len == 0, "VerQueryValue returned %u, expected 0\n", len);
522 ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n");
523
524 p = (char *)0xdeadbeef;
525 len = 0xdeadbeef;
526 SetLastError(0xdeadbeef);
527 ret = VerQueryValue(ver, "\\\\StringFileInfo", (LPVOID*)&p, &len);
528 ok(ret, "VerQueryValue error %u\n", GetLastError());
529 todo_wine ok(len == 0, "VerQueryValue returned %u, expected 0\n", len);
530 ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n");
531
532 p = (char *)0xdeadbeef;
533 len = 0xdeadbeef;
534 SetLastError(0xdeadbeef);
535 ret = VerQueryValue(ver, "\\StringFileInfo\\\\", (LPVOID*)&p, &len);
536 ok(ret, "VerQueryValue error %u\n", GetLastError());
537 todo_wine ok(len == 0, "VerQueryValue returned %u, expected 0\n", len);
538 ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n");
539
540 sprintf(buf, "\\StringFileInfo\\%08x", translation);
541 p = (char *)0xdeadbeef;
542 len = 0xdeadbeef;
543 SetLastError(0xdeadbeef);
544 ret = VerQueryValue(ver, buf, (LPVOID*)&p, &len);
545 ok(ret, "VerQueryValue error %u\n", GetLastError());
546 todo_wine ok(len == 0, "VerQueryValue returned %u, expected 0\n", len);
547 ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n");
548
549 for (i = 0; i < sizeof(value_name)/sizeof(value_name[0]); i++)
550 {
551 sprintf(buf, "\\StringFileInfo\\%08x\\%s", translation, value_name[i]);
552 p = (char *)0xdeadbeef;
553 len = 0xdeadbeef;
554 SetLastError(0xdeadbeef);
555 ret = VerQueryValue(ver, buf, (LPVOID*)&p, &len);
556 ok(ret, "VerQueryValue(%s) error %u\n", buf, GetLastError());
557 ok(len == strlen(value_name[i]) + 1, "VerQueryValue returned %u\n", len);
558 ok(!strcmp(value_name[i], p), "expected \"%s\", got \"%s\"\n",
559 value_name[i], p);
560
561 /* test partial value names */
562 len = lstrlen(buf);
563 buf[len - 2] = 0;
564 p = (char *)0xdeadbeef;
565 len = 0xdeadbeef;
566 SetLastError(0xdeadbeef);
567 ret = VerQueryValue(ver, buf, (LPVOID*)&p, &len);
568 ok(!ret, "VerQueryValue(%s) succeeded\n", buf);
569 ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND ||
570 GetLastError() == 0xdeadbeef /* NT4, W2K */,
571 "VerQueryValue returned %u\n", GetLastError());
572 ok(p == (char *)0xdeadbeef, "expected 0xdeadbeef got %p\n", p);
573 ok(len == 0, "expected 0 or 0xbeef, got %x\n", len);
574 }
575
576 HeapFree(GetProcessHeap(), 0, ver);
577 }
578
579 START_TEST(info)
580 {
581 test_info_size();
582 test_info();
583 test_32bit_win();
584 test_VerQueryValue();
585 }
586
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.