1 /*
2 * URL Cache Tests
3 *
4 * Copyright 2008 Robert Shearman for CodeWeavers
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 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wininet.h"
28 #include "winineti.h"
29
30 #include "wine/test.h"
31
32 #define TEST_URL "http://urlcachetest.winehq.org/index.html"
33 #define TEST_URL1 "Visited: user@http://urlcachetest.winehq.org/index.html"
34
35 static BOOL (WINAPI *pDeleteUrlCacheEntryA)(LPCSTR);
36 static BOOL (WINAPI *pUnlockUrlCacheEntryFileA)(LPCSTR,DWORD);
37
38 static char filenameA[MAX_PATH + 1];
39 static char filenameA1[MAX_PATH + 1];
40
41 static void check_cache_entry_infoA(const char *returnedfrom, LPINTERNET_CACHE_ENTRY_INFO lpCacheEntryInfo)
42 {
43 ok(lpCacheEntryInfo->dwStructSize == sizeof(*lpCacheEntryInfo), "%s: dwStructSize was %d\n", returnedfrom, lpCacheEntryInfo->dwStructSize);
44 ok(!strcmp(lpCacheEntryInfo->lpszSourceUrlName, TEST_URL), "%s: lpszSourceUrlName should be %s instead of %s\n", returnedfrom, TEST_URL, lpCacheEntryInfo->lpszSourceUrlName);
45 ok(!strcmp(lpCacheEntryInfo->lpszLocalFileName, filenameA), "%s: lpszLocalFileName should be %s instead of %s\n", returnedfrom, filenameA, lpCacheEntryInfo->lpszLocalFileName);
46 ok(!strcmp(lpCacheEntryInfo->lpszFileExtension, "html"), "%s: lpszFileExtension should be html instead of %s\n", returnedfrom, lpCacheEntryInfo->lpszFileExtension);
47 }
48
49 static void test_find_url_cache_entriesA(void)
50 {
51 BOOL ret;
52 HANDLE hEnumHandle;
53 BOOL found = FALSE;
54 DWORD cbCacheEntryInfo;
55 DWORD cbCacheEntryInfoSaved;
56 LPINTERNET_CACHE_ENTRY_INFO lpCacheEntryInfo;
57
58 cbCacheEntryInfo = 0;
59 SetLastError(0xdeadbeef);
60 hEnumHandle = FindFirstUrlCacheEntry(NULL, NULL, &cbCacheEntryInfo);
61 ok(!hEnumHandle, "FindFirstUrlCacheEntry should have failed\n");
62 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "FindFirstUrlCacheEntry should have set last error to ERROR_INSUFFICIENT_BUFFER instead of %d\n", GetLastError());
63 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo * sizeof(char));
64 cbCacheEntryInfoSaved = cbCacheEntryInfo;
65 hEnumHandle = FindFirstUrlCacheEntry(NULL, lpCacheEntryInfo, &cbCacheEntryInfo);
66 ok(hEnumHandle != NULL, "FindFirstUrlCacheEntry failed with error %d\n", GetLastError());
67 while (TRUE)
68 {
69 if (!strcmp(lpCacheEntryInfo->lpszSourceUrlName, TEST_URL))
70 {
71 found = TRUE;
72 ret = TRUE;
73 break;
74 }
75 SetLastError(0xdeadbeef);
76 cbCacheEntryInfo = cbCacheEntryInfoSaved;
77 ret = FindNextUrlCacheEntry(hEnumHandle, lpCacheEntryInfo, &cbCacheEntryInfo);
78 if (!ret)
79 {
80 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
81 {
82 lpCacheEntryInfo = HeapReAlloc(GetProcessHeap(), 0, lpCacheEntryInfo, cbCacheEntryInfo);
83 cbCacheEntryInfoSaved = cbCacheEntryInfo;
84 ret = FindNextUrlCacheEntry(hEnumHandle, lpCacheEntryInfo, &cbCacheEntryInfo);
85 }
86 }
87 if (!ret)
88 break;
89 }
90 ok(ret, "FindNextUrlCacheEntry failed with error %d\n", GetLastError());
91 ok(found, "Committed url cache entry not found during enumeration\n");
92
93 ret = FindCloseUrlCache(hEnumHandle);
94 ok(ret, "FindCloseUrlCache failed with error %d\n", GetLastError());
95 }
96
97 static void test_GetUrlCacheEntryInfoExA(void)
98 {
99 BOOL ret;
100 DWORD cbCacheEntryInfo, cbRedirectUrl;
101 LPINTERNET_CACHE_ENTRY_INFO lpCacheEntryInfo;
102
103 SetLastError(0xdeadbeef);
104 ret = GetUrlCacheEntryInfoEx(NULL, NULL, NULL, NULL, NULL, NULL, 0);
105 ok(!ret, "GetUrlCacheEntryInfoEx with NULL URL and NULL args should have failed\n");
106 ok(GetLastError() == ERROR_INVALID_PARAMETER,
107 "GetUrlCacheEntryInfoEx with NULL URL and NULL args should have set last error to ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
108
109 cbCacheEntryInfo = sizeof(INTERNET_CACHE_ENTRY_INFO);
110 SetLastError(0xdeadbeef);
111 ret = GetUrlCacheEntryInfoEx("", NULL, &cbCacheEntryInfo, NULL, NULL, NULL, 0);
112 ok(!ret, "GetUrlCacheEntryInfoEx with zero-length buffer should fail\n");
113 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
114 "GetUrlCacheEntryInfoEx should have set last error to ERROR_FILE_NOT_FOUND instead of %d\n", GetLastError());
115
116 ret = GetUrlCacheEntryInfoEx(TEST_URL, NULL, NULL, NULL, NULL, NULL, 0);
117 ok(ret, "GetUrlCacheEntryInfoEx with NULL args failed with error %d\n", GetLastError());
118
119 cbCacheEntryInfo = 0;
120 SetLastError(0xdeadbeef);
121 ret = GetUrlCacheEntryInfoEx(TEST_URL, NULL, &cbCacheEntryInfo, NULL, NULL, NULL, 0);
122 ok(!ret, "GetUrlCacheEntryInfoEx with zero-length buffer should fail\n");
123 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
124 "GetUrlCacheEntryInfoEx should have set last error to ERROR_INSUFFICIENT_BUFFER instead of %d\n", GetLastError());
125
126 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
127
128 SetLastError(0xdeadbeef);
129 ret = GetUrlCacheEntryInfoEx(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo, NULL, NULL, NULL, 0x200);
130 ok(!ret, "GetUrlCacheEntryInfoEx succeeded\n");
131 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
132 "GetUrlCacheEntryInfoEx should have set last error to ERROR_FILE_NOT_FOUND instead of %d\n", GetLastError());
133
134 ret = GetUrlCacheEntryInfoEx(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo, NULL, NULL, NULL, 0);
135 ok(ret, "GetUrlCacheEntryInfoEx failed with error %d\n", GetLastError());
136
137 if (ret) check_cache_entry_infoA("GetUrlCacheEntryInfoEx", lpCacheEntryInfo);
138
139 cbCacheEntryInfo = 100000;
140 SetLastError(0xdeadbeef);
141 ret = GetUrlCacheEntryInfoEx(TEST_URL, NULL, &cbCacheEntryInfo, NULL, NULL, NULL, 0);
142 ok(!ret, "GetUrlCacheEntryInfoEx with zero-length buffer should fail\n");
143 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetUrlCacheEntryInfoEx should have set last error to ERROR_INSUFFICIENT_BUFFER instead of %d\n", GetLastError());
144
145 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
146
147 /* Querying the redirect URL fails with ERROR_INVALID_PARAMETER */
148 SetLastError(0xdeadbeef);
149 ret = GetUrlCacheEntryInfoEx(TEST_URL, NULL, NULL, NULL, &cbRedirectUrl, NULL, 0);
150 ok(!ret, "GetUrlCacheEntryInfoEx should have failed\n");
151 ok(GetLastError() == ERROR_INVALID_PARAMETER,
152 "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
153 SetLastError(0xdeadbeef);
154 ret = GetUrlCacheEntryInfoEx(TEST_URL, NULL, &cbCacheEntryInfo, NULL, &cbRedirectUrl, NULL, 0);
155 ok(!ret, "GetUrlCacheEntryInfoEx should have failed\n");
156 ok(GetLastError() == ERROR_INVALID_PARAMETER,
157 "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
158 }
159
160 static void test_RetrieveUrlCacheEntryA(void)
161 {
162 BOOL ret;
163 DWORD cbCacheEntryInfo;
164
165 cbCacheEntryInfo = 0;
166 SetLastError(0xdeadbeef);
167 ret = RetrieveUrlCacheEntryFile(NULL, NULL, &cbCacheEntryInfo, 0);
168 ok(!ret, "RetrieveUrlCacheEntryFile should have failed\n");
169 ok(GetLastError() == ERROR_INVALID_PARAMETER, "RetrieveUrlCacheEntryFile should have set last error to ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
170
171 if (0)
172 {
173 /* Crashes on Win9x, NT4 and W2K */
174 SetLastError(0xdeadbeef);
175 ret = RetrieveUrlCacheEntryFile(TEST_URL, NULL, NULL, 0);
176 ok(!ret, "RetrieveUrlCacheEntryFile should have failed\n");
177 ok(GetLastError() == ERROR_INVALID_PARAMETER, "RetrieveUrlCacheEntryFile should have set last error to ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
178 }
179
180 SetLastError(0xdeadbeef);
181 cbCacheEntryInfo = 100000;
182 ret = RetrieveUrlCacheEntryFile(NULL, NULL, &cbCacheEntryInfo, 0);
183 ok(!ret, "RetrieveUrlCacheEntryFile should have failed\n");
184 ok(GetLastError() == ERROR_INVALID_PARAMETER, "RetrieveUrlCacheEntryFile should have set last error to ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
185 }
186
187 static void test_IsUrlCacheEntryExpiredA(void)
188 {
189 static const char uncached_url[] =
190 "What's the airspeed velocity of an unladen swallow?";
191 BOOL ret;
192 FILETIME ft;
193 DWORD size;
194 LPINTERNET_CACHE_ENTRY_INFO info;
195 ULARGE_INTEGER exp_time;
196
197 /* The function returns TRUE when the output time is NULL or the tested URL
198 * is NULL.
199 */
200 ret = IsUrlCacheEntryExpiredA(NULL, 0, NULL);
201 ok(ret, "expected TRUE\n");
202 ft.dwLowDateTime = 0xdeadbeef;
203 ft.dwHighDateTime = 0xbaadf00d;
204 ret = IsUrlCacheEntryExpiredA(NULL, 0, &ft);
205 ok(ret, "expected TRUE\n");
206 ok(ft.dwLowDateTime == 0xdeadbeef && ft.dwHighDateTime == 0xbaadf00d,
207 "expected time to be unchanged, got (%u,%u)\n",
208 ft.dwLowDateTime, ft.dwHighDateTime);
209 ret = IsUrlCacheEntryExpiredA(TEST_URL, 0, NULL);
210 ok(ret, "expected TRUE\n");
211
212 /* The return value should indicate whether the URL is expired,
213 * and the filetime indicates the last modified time, but a cache entry
214 * with a zero expire time is "not expired".
215 */
216 ft.dwLowDateTime = 0xdeadbeef;
217 ft.dwHighDateTime = 0xbaadf00d;
218 ret = IsUrlCacheEntryExpiredA(TEST_URL, 0, &ft);
219 ok(!ret, "expected FALSE\n");
220 ok(!ft.dwLowDateTime && !ft.dwHighDateTime,
221 "expected time (0,0), got (%u,%u)\n",
222 ft.dwLowDateTime, ft.dwHighDateTime);
223
224 /* Same behavior with bogus flags. */
225 ft.dwLowDateTime = 0xdeadbeef;
226 ft.dwHighDateTime = 0xbaadf00d;
227 ret = IsUrlCacheEntryExpiredA(TEST_URL, 0xffffffff, &ft);
228 ok(!ret, "expected FALSE\n");
229 ok(!ft.dwLowDateTime && !ft.dwHighDateTime,
230 "expected time (0,0), got (%u,%u)\n",
231 ft.dwLowDateTime, ft.dwHighDateTime);
232
233 /* Set the expire time to a point in the past.. */
234 ret = GetUrlCacheEntryInfo(TEST_URL, NULL, &size);
235 ok(!ret, "GetUrlCacheEntryInfo should have failed\n");
236 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
237 "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
238 info = HeapAlloc(GetProcessHeap(), 0, size);
239 ret = GetUrlCacheEntryInfo(TEST_URL, info, &size);
240 ok(ret, "GetUrlCacheEntryInfo failed: %d\n", GetLastError());
241 GetSystemTimeAsFileTime(&info->ExpireTime);
242 exp_time.u.LowPart = info->ExpireTime.dwLowDateTime;
243 exp_time.u.HighPart = info->ExpireTime.dwHighDateTime;
244 exp_time.QuadPart -= 10 * 60 * (ULONGLONG)10000000;
245 info->ExpireTime.dwLowDateTime = exp_time.u.LowPart;
246 info->ExpireTime.dwHighDateTime = exp_time.u.HighPart;
247 ret = SetUrlCacheEntryInfo(TEST_URL, info, CACHE_ENTRY_EXPTIME_FC);
248 ok(ret, "SetUrlCacheEntryInfo failed: %d\n", GetLastError());
249 ft.dwLowDateTime = 0xdeadbeef;
250 ft.dwHighDateTime = 0xbaadf00d;
251 /* and the entry should be expired. */
252 ret = IsUrlCacheEntryExpiredA(TEST_URL, 0, &ft);
253 ok(ret, "expected TRUE\n");
254 /* The modified time returned is 0. */
255 ok(!ft.dwLowDateTime && !ft.dwHighDateTime,
256 "expected time (0,0), got (%u,%u)\n",
257 ft.dwLowDateTime, ft.dwHighDateTime);
258 /* Set the expire time to a point in the future.. */
259 exp_time.QuadPart += 20 * 60 * (ULONGLONG)10000000;
260 info->ExpireTime.dwLowDateTime = exp_time.u.LowPart;
261 info->ExpireTime.dwHighDateTime = exp_time.u.HighPart;
262 ret = SetUrlCacheEntryInfo(TEST_URL, info, CACHE_ENTRY_EXPTIME_FC);
263 ok(ret, "SetUrlCacheEntryInfo failed: %d\n", GetLastError());
264 ft.dwLowDateTime = 0xdeadbeef;
265 ft.dwHighDateTime = 0xbaadf00d;
266 /* and the entry should no longer be expired. */
267 ret = IsUrlCacheEntryExpiredA(TEST_URL, 0, &ft);
268 ok(!ret, "expected FALSE\n");
269 /* The modified time returned is still 0. */
270 ok(!ft.dwLowDateTime && !ft.dwHighDateTime,
271 "expected time (0,0), got (%u,%u)\n",
272 ft.dwLowDateTime, ft.dwHighDateTime);
273 /* Set the modified time... */
274 GetSystemTimeAsFileTime(&info->LastModifiedTime);
275 ret = SetUrlCacheEntryInfo(TEST_URL, info, CACHE_ENTRY_MODTIME_FC);
276 ok(ret, "SetUrlCacheEntryInfo failed: %d\n", GetLastError());
277 /* and the entry should still be unexpired.. */
278 ret = IsUrlCacheEntryExpiredA(TEST_URL, 0, &ft);
279 ok(!ret, "expected FALSE\n");
280 /* but the modified time returned is the last modified time just set. */
281 ok(ft.dwLowDateTime == info->LastModifiedTime.dwLowDateTime &&
282 ft.dwHighDateTime == info->LastModifiedTime.dwHighDateTime,
283 "expected time (%u,%u), got (%u,%u)\n",
284 info->LastModifiedTime.dwLowDateTime,
285 info->LastModifiedTime.dwHighDateTime,
286 ft.dwLowDateTime, ft.dwHighDateTime);
287 HeapFree(GetProcessHeap(), 0, info);
288
289 /* An uncached URL is implicitly expired, but with unknown time. */
290 ft.dwLowDateTime = 0xdeadbeef;
291 ft.dwHighDateTime = 0xbaadf00d;
292 ret = IsUrlCacheEntryExpiredA(uncached_url, 0, &ft);
293 ok(ret, "expected TRUE\n");
294 ok(!ft.dwLowDateTime && !ft.dwHighDateTime,
295 "expected time (0,0), got (%u,%u)\n",
296 ft.dwLowDateTime, ft.dwHighDateTime);
297 }
298
299 static void _check_file_exists(LONG l, LPCSTR filename)
300 {
301 HANDLE file;
302
303 file = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
304 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
305 ok_(__FILE__,l)(file != INVALID_HANDLE_VALUE,
306 "expected file to exist, CreateFile failed with error %d\n",
307 GetLastError());
308 CloseHandle(file);
309 }
310
311 #define check_file_exists(f) _check_file_exists(__LINE__, f)
312
313 static void _check_file_not_exists(LONG l, LPCSTR filename)
314 {
315 HANDLE file;
316
317 file = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
318 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
319 ok_(__FILE__,l)(file == INVALID_HANDLE_VALUE,
320 "expected file not to exist\n");
321 if (file != INVALID_HANDLE_VALUE)
322 CloseHandle(file);
323 }
324
325 #define check_file_not_exists(f) _check_file_not_exists(__LINE__, f)
326
327 static void create_and_write_file(LPCSTR filename, void *data, DWORD len)
328 {
329 HANDLE file;
330 DWORD written;
331 BOOL ret;
332
333 file = CreateFileA(filename, GENERIC_WRITE,
334 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,
335 FILE_ATTRIBUTE_NORMAL, NULL);
336 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed with error %d\n", GetLastError());
337
338 ret = WriteFile(file, data, len, &written, NULL);
339 ok(ret, "WriteFile failed with error %d\n", GetLastError());
340
341 CloseHandle(file);
342 }
343
344 static void test_urlcacheA(void)
345 {
346 static char ok_header[] = "HTTP/1.0 200 OK\r\n\r\n";
347 BOOL ret;
348 HANDLE hFile;
349 BYTE zero_byte = 0;
350 LPINTERNET_CACHE_ENTRY_INFO lpCacheEntryInfo;
351 LPINTERNET_CACHE_ENTRY_INFO lpCacheEntryInfo2;
352 DWORD cbCacheEntryInfo;
353 static const FILETIME filetime_zero;
354 FILETIME now;
355
356 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA, 0);
357 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
358
359 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA1, 0);
360 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
361
362 ok(lstrcmpiA(filenameA, filenameA1), "expected a different file name\n");
363
364 create_and_write_file(filenameA, &zero_byte, sizeof(zero_byte));
365
366 ret = CommitUrlCacheEntry(TEST_URL1, NULL, filetime_zero, filetime_zero, NORMAL_CACHE_ENTRY|URLHISTORY_CACHE_ENTRY, NULL, 0, "html", NULL);
367 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
368 cbCacheEntryInfo = 0;
369 ret = GetUrlCacheEntryInfo(TEST_URL1, NULL, &cbCacheEntryInfo);
370 ok(!ret, "GetUrlCacheEntryInfo should have failed\n");
371 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
372 "GetUrlCacheEntryInfo should have set last error to ERROR_INSUFFICIENT_BUFFER instead of %d\n", GetLastError());
373 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
374 ret = GetUrlCacheEntryInfo(TEST_URL1, lpCacheEntryInfo, &cbCacheEntryInfo);
375 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
376 ok(!memcmp(&lpCacheEntryInfo->ExpireTime, &filetime_zero, sizeof(FILETIME)),
377 "expected zero ExpireTime\n");
378 ok(!memcmp(&lpCacheEntryInfo->LastModifiedTime, &filetime_zero, sizeof(FILETIME)),
379 "expected zero LastModifiedTime\n");
380 ok(lpCacheEntryInfo->CacheEntryType == (NORMAL_CACHE_ENTRY|URLHISTORY_CACHE_ENTRY) ||
381 broken(lpCacheEntryInfo->CacheEntryType == NORMAL_CACHE_ENTRY /* NT4/W2k */),
382 "expected type NORMAL_CACHE_ENTRY|URLHISTORY_CACHE_ENTRY, got %08x\n",
383 lpCacheEntryInfo->CacheEntryType);
384 ok(!U(*lpCacheEntryInfo).dwExemptDelta, "expected dwExemptDelta 0, got %d\n",
385 U(*lpCacheEntryInfo).dwExemptDelta);
386
387 /* Make sure there is a notable change in timestamps */
388 Sleep(1000);
389
390 /* A subsequent commit with a different time/type doesn't change most of the entry */
391 GetSystemTimeAsFileTime(&now);
392 ret = CommitUrlCacheEntry(TEST_URL1, NULL, now, now, NORMAL_CACHE_ENTRY,
393 (LPBYTE)ok_header, strlen(ok_header), NULL, NULL);
394 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
395 cbCacheEntryInfo = 0;
396 ret = GetUrlCacheEntryInfo(TEST_URL1, NULL, &cbCacheEntryInfo);
397 ok(!ret, "GetUrlCacheEntryInfo should have failed\n");
398 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
399 "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
400 lpCacheEntryInfo2 = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
401 ret = GetUrlCacheEntryInfo(TEST_URL1, lpCacheEntryInfo2, &cbCacheEntryInfo);
402 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
403 /* but it does change the time.. */
404 todo_wine
405 ok(memcmp(&lpCacheEntryInfo2->ExpireTime, &filetime_zero, sizeof(FILETIME)),
406 "expected positive ExpireTime\n");
407 todo_wine
408 ok(memcmp(&lpCacheEntryInfo2->LastModifiedTime, &filetime_zero, sizeof(FILETIME)),
409 "expected positive LastModifiedTime\n");
410 ok(lpCacheEntryInfo2->CacheEntryType == (NORMAL_CACHE_ENTRY|URLHISTORY_CACHE_ENTRY) ||
411 broken(lpCacheEntryInfo2->CacheEntryType == NORMAL_CACHE_ENTRY /* NT4/W2k */),
412 "expected type NORMAL_CACHE_ENTRY|URLHISTORY_CACHE_ENTRY, got %08x\n",
413 lpCacheEntryInfo2->CacheEntryType);
414 /* and set the headers. */
415 todo_wine
416 ok(lpCacheEntryInfo2->dwHeaderInfoSize == 19,
417 "expected headers size 19, got %d\n",
418 lpCacheEntryInfo2->dwHeaderInfoSize);
419 /* Hit rate gets incremented by 1 */
420 todo_wine
421 ok((lpCacheEntryInfo->dwHitRate + 1) == lpCacheEntryInfo2->dwHitRate,
422 "HitRate not incremented by one on commit\n");
423 /* Last access time should be updated */
424 todo_wine
425 ok(!(lpCacheEntryInfo->LastAccessTime.dwHighDateTime == lpCacheEntryInfo2->LastAccessTime.dwHighDateTime &&
426 lpCacheEntryInfo->LastAccessTime.dwLowDateTime == lpCacheEntryInfo2->LastAccessTime.dwLowDateTime),
427 "Last accessed time was not updated by commit\n");
428 /* File extension should be unset */
429 todo_wine
430 ok(lpCacheEntryInfo2->lpszFileExtension == NULL,
431 "Fileextension isn't unset: %s\n",
432 lpCacheEntryInfo2->lpszFileExtension);
433 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
434 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo2);
435
436 ret = CommitUrlCacheEntry(TEST_URL, filenameA, filetime_zero, filetime_zero, NORMAL_CACHE_ENTRY, NULL, 0, "html", NULL);
437 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
438
439 cbCacheEntryInfo = 0;
440 SetLastError(0xdeadbeef);
441 ret = RetrieveUrlCacheEntryFile(TEST_URL, NULL, &cbCacheEntryInfo, 0);
442 ok(!ret, "RetrieveUrlCacheEntryFile should have failed\n");
443 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
444 "RetrieveUrlCacheEntryFile should have set last error to ERROR_INSUFFICIENT_BUFFER instead of %d\n", GetLastError());
445
446 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
447 ret = RetrieveUrlCacheEntryFile(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo, 0);
448 ok(ret, "RetrieveUrlCacheEntryFile failed with error %d\n", GetLastError());
449
450 if (ret) check_cache_entry_infoA("RetrieveUrlCacheEntryFile", lpCacheEntryInfo);
451
452 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
453
454 cbCacheEntryInfo = 0;
455 SetLastError(0xdeadbeef);
456 ret = RetrieveUrlCacheEntryFile(TEST_URL1, NULL, &cbCacheEntryInfo, 0);
457 ok(!ret, "RetrieveUrlCacheEntryFile should have failed\n");
458 ok(GetLastError() == ERROR_INVALID_DATA,
459 "RetrieveUrlCacheEntryFile should have set last error to ERROR_INVALID_DATA instead of %d\n", GetLastError());
460
461 if (pUnlockUrlCacheEntryFileA)
462 {
463 ret = pUnlockUrlCacheEntryFileA(TEST_URL, 0);
464 ok(ret, "UnlockUrlCacheEntryFileA failed with error %d\n", GetLastError());
465 }
466
467 /* test Find*UrlCacheEntry functions */
468 test_find_url_cache_entriesA();
469
470 test_GetUrlCacheEntryInfoExA();
471 test_RetrieveUrlCacheEntryA();
472 test_IsUrlCacheEntryExpiredA();
473
474 if (pDeleteUrlCacheEntryA)
475 {
476 ret = pDeleteUrlCacheEntryA(TEST_URL);
477 ok(ret, "DeleteUrlCacheEntryA failed with error %d\n", GetLastError());
478 ret = pDeleteUrlCacheEntryA(TEST_URL1);
479 ok(ret, "DeleteUrlCacheEntryA failed with error %d\n", GetLastError());
480 }
481
482 SetLastError(0xdeadbeef);
483 ret = DeleteFile(filenameA);
484 todo_wine
485 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "local file should no longer exist\n");
486
487 /* Creating two entries with the same URL */
488 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA, 0);
489 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
490
491 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA1, 0);
492 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
493
494 ok(lstrcmpiA(filenameA, filenameA1), "expected a different file name\n");
495
496 create_and_write_file(filenameA, &zero_byte, sizeof(zero_byte));
497 create_and_write_file(filenameA1, &zero_byte, sizeof(zero_byte));
498 check_file_exists(filenameA);
499 check_file_exists(filenameA1);
500
501 ret = CommitUrlCacheEntry(TEST_URL, filenameA, filetime_zero,
502 filetime_zero, NORMAL_CACHE_ENTRY, (LPBYTE)ok_header,
503 strlen(ok_header), "html", NULL);
504 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
505 check_file_exists(filenameA);
506 check_file_exists(filenameA1);
507 ret = CommitUrlCacheEntry(TEST_URL, filenameA1, filetime_zero,
508 filetime_zero, COOKIE_CACHE_ENTRY, NULL, 0, "html", NULL);
509 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
510 /* By committing the same URL a second time, the prior entry is
511 * overwritten...
512 */
513 cbCacheEntryInfo = 0;
514 SetLastError(0xdeadbeef);
515 ret = GetUrlCacheEntryInfo(TEST_URL, NULL, &cbCacheEntryInfo);
516 ok(!ret, "GetUrlCacheEntryInfo should have failed\n");
517 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
518 "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
519 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
520 ret = GetUrlCacheEntryInfo(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo);
521 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
522 /* with the previous entry type retained.. */
523 ok(lpCacheEntryInfo->CacheEntryType & NORMAL_CACHE_ENTRY,
524 "expected cache entry type NORMAL_CACHE_ENTRY, got %d (0x%08x)\n",
525 lpCacheEntryInfo->CacheEntryType, lpCacheEntryInfo->CacheEntryType);
526 /* and the headers overwritten.. */
527 todo_wine
528 ok(!lpCacheEntryInfo->dwHeaderInfoSize, "expected headers size 0, got %d\n",
529 lpCacheEntryInfo->dwHeaderInfoSize);
530 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
531 /* and the previous filename shouldn't exist. */
532 todo_wine
533 check_file_not_exists(filenameA);
534 check_file_exists(filenameA1);
535
536 if (pDeleteUrlCacheEntryA)
537 {
538 ret = pDeleteUrlCacheEntryA(TEST_URL);
539 ok(ret, "DeleteUrlCacheEntryA failed with error %d\n", GetLastError());
540 todo_wine
541 check_file_not_exists(filenameA);
542 todo_wine
543 check_file_not_exists(filenameA1);
544 /* Just in case, clean up files */
545 DeleteFileA(filenameA1);
546 DeleteFileA(filenameA);
547 }
548
549 /* Check whether a retrieved cache entry can be deleted before it's
550 * unlocked:
551 */
552 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA, 0);
553 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
554 ret = CommitUrlCacheEntry(TEST_URL, filenameA, filetime_zero, filetime_zero,
555 NORMAL_CACHE_ENTRY, NULL, 0, "html", NULL);
556 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
557
558 cbCacheEntryInfo = 0;
559 SetLastError(0xdeadbeef);
560 ret = RetrieveUrlCacheEntryFile(TEST_URL, NULL, &cbCacheEntryInfo, 0);
561 ok(!ret, "RetrieveUrlCacheEntryFile should have failed\n");
562 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
563 "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
564
565 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
566 ret = RetrieveUrlCacheEntryFile(TEST_URL, lpCacheEntryInfo,
567 &cbCacheEntryInfo, 0);
568 ok(ret, "RetrieveUrlCacheEntryFile failed with error %d\n", GetLastError());
569
570 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
571
572 if (pDeleteUrlCacheEntryA)
573 {
574 ret = pDeleteUrlCacheEntryA(TEST_URL);
575 ok(!ret, "Expected failure\n");
576 ok(GetLastError() == ERROR_SHARING_VIOLATION,
577 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
578 check_file_exists(filenameA);
579 }
580
581 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
582 memset(lpCacheEntryInfo, 0, cbCacheEntryInfo);
583 ret = GetUrlCacheEntryInfo(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo);
584 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
585 ok(lpCacheEntryInfo->CacheEntryType & DELETED_CACHE_ENTRY,
586 "CacheEntryType hasn't DELETED_CACHE_ENTRY set, (flags %08x)\n",
587 lpCacheEntryInfo->CacheEntryType);
588 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
589
590 if (pUnlockUrlCacheEntryFileA)
591 {
592 check_file_exists(filenameA);
593 ret = pUnlockUrlCacheEntryFileA(TEST_URL, 0);
594 ok(ret, "UnlockUrlCacheEntryFileA failed: %d\n", GetLastError());
595 /* By unlocking the already-deleted cache entry, the file associated
596 * with it is deleted..
597 */
598 todo_wine
599 check_file_not_exists(filenameA);
600 /* (just in case, delete file) */
601 DeleteFileA(filenameA);
602 }
603 if (pDeleteUrlCacheEntryA)
604 {
605 /* and a subsequent deletion should fail. */
606 ret = pDeleteUrlCacheEntryA(TEST_URL);
607 ok(!ret, "Expected failure\n");
608 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
609 "expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
610 }
611
612 /* Test whether preventing a file from being deleted causes
613 * DeleteUrlCacheEntryA to fail.
614 */
615 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA, 0);
616 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
617
618 create_and_write_file(filenameA, &zero_byte, sizeof(zero_byte));
619 check_file_exists(filenameA);
620
621 ret = CommitUrlCacheEntry(TEST_URL, filenameA, filetime_zero,
622 filetime_zero, NORMAL_CACHE_ENTRY, (LPBYTE)ok_header,
623 strlen(ok_header), "html", NULL);
624 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
625 check_file_exists(filenameA);
626 hFile = CreateFileA(filenameA, GENERIC_READ, 0, NULL, OPEN_EXISTING,
627 FILE_ATTRIBUTE_NORMAL, NULL);
628 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA failed: %d\n",
629 GetLastError());
630 if (pDeleteUrlCacheEntryA)
631 {
632 /* DeleteUrlCacheEntryA should succeed.. */
633 ret = pDeleteUrlCacheEntryA(TEST_URL);
634 ok(ret, "DeleteUrlCacheEntryA failed with error %d\n", GetLastError());
635 }
636 CloseHandle(hFile);
637 if (pDeleteUrlCacheEntryA)
638 {
639 /* and a subsequent deletion should fail.. */
640 ret = pDeleteUrlCacheEntryA(TEST_URL);
641 ok(!ret, "Expected failure\n");
642 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
643 "expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
644 }
645 /* and the file should be untouched. */
646 check_file_exists(filenameA);
647 DeleteFileA(filenameA);
648
649 /* Try creating a sticky entry. Unlike non-sticky entries, the filename
650 * must have been set already.
651 */
652 SetLastError(0xdeadbeef);
653 ret = CommitUrlCacheEntry(TEST_URL, NULL, filetime_zero, filetime_zero,
654 STICKY_CACHE_ENTRY, (LPBYTE)ok_header, strlen(ok_header), "html",
655 NULL);
656 ok(!ret, "expected failure\n");
657 ok(GetLastError() == ERROR_INVALID_PARAMETER,
658 "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
659 SetLastError(0xdeadbeef);
660 ret = CommitUrlCacheEntry(TEST_URL, NULL, filetime_zero, filetime_zero,
661 NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY,
662 (LPBYTE)ok_header, strlen(ok_header), "html", NULL);
663 ok(!ret, "expected failure\n");
664 ok(GetLastError() == ERROR_INVALID_PARAMETER,
665 "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
666
667 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA, 0);
668 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
669 create_and_write_file(filenameA, &zero_byte, sizeof(zero_byte));
670 ret = CommitUrlCacheEntry(TEST_URL, filenameA, filetime_zero, filetime_zero,
671 NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY,
672 (LPBYTE)ok_header, strlen(ok_header), "html", NULL);
673 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
674 cbCacheEntryInfo = 0;
675 SetLastError(0xdeadbeef);
676 ret = GetUrlCacheEntryInfo(TEST_URL, NULL, &cbCacheEntryInfo);
677 ok(!ret, "GetUrlCacheEntryInfo should have failed\n");
678 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
679 "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
680 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
681 ret = GetUrlCacheEntryInfo(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo);
682 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
683 ok(lpCacheEntryInfo->CacheEntryType & (NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY),
684 "expected cache entry type NORMAL_CACHE_ENTRY | STICKY_CACHE_ENTRY, got %d (0x%08x)\n",
685 lpCacheEntryInfo->CacheEntryType, lpCacheEntryInfo->CacheEntryType);
686 ok(U(*lpCacheEntryInfo).dwExemptDelta == 86400,
687 "expected dwExemptDelta 86400, got %d\n",
688 U(*lpCacheEntryInfo).dwExemptDelta);
689 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
690 if (pDeleteUrlCacheEntryA)
691 {
692 ret = pDeleteUrlCacheEntryA(TEST_URL);
693 ok(ret, "DeleteUrlCacheEntryA failed with error %d\n", GetLastError());
694 /* When explicitly deleting the cache entry, the file is also deleted */
695 todo_wine
696 check_file_not_exists(filenameA);
697 }
698 /* Test once again, setting the exempt delta via SetUrlCacheEntryInfo */
699 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA, 0);
700 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
701 create_and_write_file(filenameA, &zero_byte, sizeof(zero_byte));
702 ret = CommitUrlCacheEntry(TEST_URL, filenameA, filetime_zero, filetime_zero,
703 NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY,
704 (LPBYTE)ok_header, strlen(ok_header), "html", NULL);
705 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
706 cbCacheEntryInfo = 0;
707 SetLastError(0xdeadbeef);
708 ret = GetUrlCacheEntryInfo(TEST_URL, NULL, &cbCacheEntryInfo);
709 ok(!ret, "GetUrlCacheEntryInfo should have failed\n");
710 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
711 "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
712 lpCacheEntryInfo = HeapAlloc(GetProcessHeap(), 0, cbCacheEntryInfo);
713 ret = GetUrlCacheEntryInfo(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo);
714 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
715 ok(lpCacheEntryInfo->CacheEntryType & (NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY),
716 "expected cache entry type NORMAL_CACHE_ENTRY | STICKY_CACHE_ENTRY, got %d (0x%08x)\n",
717 lpCacheEntryInfo->CacheEntryType, lpCacheEntryInfo->CacheEntryType);
718 ok(U(*lpCacheEntryInfo).dwExemptDelta == 86400,
719 "expected dwExemptDelta 86400, got %d\n",
720 U(*lpCacheEntryInfo).dwExemptDelta);
721 U(*lpCacheEntryInfo).dwExemptDelta = 0;
722 ret = SetUrlCacheEntryInfoA(TEST_URL, lpCacheEntryInfo,
723 CACHE_ENTRY_EXEMPT_DELTA_FC);
724 ok(ret, "SetUrlCacheEntryInfo failed: %d\n", GetLastError());
725 ret = GetUrlCacheEntryInfo(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo);
726 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
727 ok(!U(*lpCacheEntryInfo).dwExemptDelta, "expected dwExemptDelta 0, got %d\n",
728 U(*lpCacheEntryInfo).dwExemptDelta);
729 /* See whether a sticky cache entry has the flag cleared once the exempt
730 * delta is meaningless.
731 */
732 ok(lpCacheEntryInfo->CacheEntryType & (NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY),
733 "expected cache entry type NORMAL_CACHE_ENTRY | STICKY_CACHE_ENTRY, got %d (0x%08x)\n",
734 lpCacheEntryInfo->CacheEntryType, lpCacheEntryInfo->CacheEntryType);
735
736 /* Recommit of Url entry keeps dwExemptDelta */
737 U(*lpCacheEntryInfo).dwExemptDelta = 8600;
738 ret = SetUrlCacheEntryInfoA(TEST_URL, lpCacheEntryInfo,
739 CACHE_ENTRY_EXEMPT_DELTA_FC);
740 ok(ret, "SetUrlCacheEntryInfo failed: %d\n", GetLastError());
741
742 ret = CreateUrlCacheEntry(TEST_URL, 0, "html", filenameA1, 0);
743 ok(ret, "CreateUrlCacheEntry failed with error %d\n", GetLastError());
744 create_and_write_file(filenameA1, &zero_byte, sizeof(zero_byte));
745
746 ret = CommitUrlCacheEntry(TEST_URL, filenameA1, filetime_zero, filetime_zero,
747 NORMAL_CACHE_ENTRY|STICKY_CACHE_ENTRY,
748 (LPBYTE)ok_header, strlen(ok_header), "html", NULL);
749 ok(ret, "CommitUrlCacheEntry failed with error %d\n", GetLastError());
750
751 ret = GetUrlCacheEntryInfo(TEST_URL, lpCacheEntryInfo, &cbCacheEntryInfo);
752 ok(ret, "GetUrlCacheEntryInfo failed with error %d\n", GetLastError());
753 ok(U(*lpCacheEntryInfo).dwExemptDelta == 8600,
754 "expected dwExemptDelta 8600, got %d\n",
755 U(*lpCacheEntryInfo).dwExemptDelta);
756
757 HeapFree(GetProcessHeap(), 0, lpCacheEntryInfo);
758
759 if (pDeleteUrlCacheEntryA)
760 {
761 ret = pDeleteUrlCacheEntryA(TEST_URL);
762 ok(ret, "DeleteUrlCacheEntryA failed with error %d\n", GetLastError());
763 todo_wine
764 check_file_not_exists(filenameA);
765 }
766 }
767
768 static void test_FindCloseUrlCache(void)
769 {
770 BOOL r;
771 DWORD err;
772
773 SetLastError(0xdeadbeef);
774 r = FindCloseUrlCache(NULL);
775 err = GetLastError();
776 ok(0 == r, "expected 0, got %d\n", r);
777 ok(ERROR_INVALID_HANDLE == err, "expected %d, got %d\n", ERROR_INVALID_HANDLE, err);
778 }
779
780 static void test_GetDiskInfoA(void)
781 {
782 BOOL ret;
783 DWORD error, cluster_size;
784 DWORDLONG free, total;
785 char path[MAX_PATH], *p;
786
787 GetSystemDirectoryA(path, MAX_PATH);
788 if ((p = strchr(path, '\\'))) *++p = 0;
789
790 ret = GetDiskInfoA(path, &cluster_size, &free, &total);
791 ok(ret, "GetDiskInfoA failed %u\n", GetLastError());
792
793 ret = GetDiskInfoA(path, &cluster_size, &free, NULL);
794 ok(ret, "GetDiskInfoA failed %u\n", GetLastError());
795
796 ret = GetDiskInfoA(path, &cluster_size, NULL, NULL);
797 ok(ret, "GetDiskInfoA failed %u\n", GetLastError());
798
799 ret = GetDiskInfoA(path, NULL, NULL, NULL);
800 ok(ret, "GetDiskInfoA failed %u\n", GetLastError());
801
802 SetLastError(0xdeadbeef);
803 strcpy(p, "\\non\\existing\\path");
804 ret = GetDiskInfoA(path, NULL, NULL, NULL);
805 error = GetLastError();
806 ok(!ret ||
807 broken(ret), /* < IE7 */
808 "GetDiskInfoA succeeded\n");
809 ok(error == ERROR_PATH_NOT_FOUND ||
810 broken(error == 0xdeadbeef), /* < IE7 */
811 "got %u expected ERROR_PATH_NOT_FOUND\n", error);
812
813 SetLastError(0xdeadbeef);
814 ret = GetDiskInfoA(NULL, NULL, NULL, NULL);
815 error = GetLastError();
816 ok(!ret, "GetDiskInfoA succeeded\n");
817 ok(error == ERROR_INVALID_PARAMETER, "got %u expected ERROR_INVALID_PARAMETER\n", error);
818 }
819
820 START_TEST(urlcache)
821 {
822 HMODULE hdll;
823 hdll = GetModuleHandleA("wininet.dll");
824
825 if(!GetProcAddress(hdll, "InternetGetCookieExW")) {
826 win_skip("Too old IE (older than 6.0)\n");
827 return;
828 }
829
830 pDeleteUrlCacheEntryA = (void*)GetProcAddress(hdll, "DeleteUrlCacheEntryA");
831 pUnlockUrlCacheEntryFileA = (void*)GetProcAddress(hdll, "UnlockUrlCacheEntryFileA");
832 test_urlcacheA();
833 test_FindCloseUrlCache();
834 test_GetDiskInfoA();
835 }
836
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.