mshtml: Store document as IHTMLDocument2 interface.
[wine] / dlls / mshtml / tests / protocol.c
1 /*
2  * Copyright 2005 Jacek Caban
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 #define COBJMACROS
20
21 #include <wine/test.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "ole2.h"
28 #include "urlmon.h"
29 #include "shlwapi.h"
30
31 #include "initguid.h"
32
33 #define DEFINE_EXPECT(func) \
34     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
35
36 #define SET_EXPECT(func) \
37     expect_ ## func = TRUE
38
39 #define CHECK_EXPECT(func) \
40     do { \
41         ok(expect_ ##func, "unexpected call " #func "\n"); \
42         expect_ ## func = FALSE; \
43         called_ ## func = TRUE; \
44     }while(0)
45
46 #define CHECK_EXPECT2(func) \
47     do { \
48         ok(expect_ ##func, "unexpected call " #func  "\n"); \
49         called_ ## func = TRUE; \
50     }while(0)
51
52 #define CHECK_CALLED(func) \
53     do { \
54         ok(called_ ## func, "expected " #func "\n"); \
55         expect_ ## func = called_ ## func = FALSE; \
56     }while(0)
57
58 DEFINE_GUID(CLSID_ResProtocol, 0x3050F3BC, 0x98B5, 0x11CF, 0xBB,0x82, 0x00,0xAA,0x00,0xBD,0xCE,0x0B);
59 DEFINE_GUID(CLSID_AboutProtocol, 0x3050F406, 0x98B5, 0x11CF, 0xBB,0x82, 0x00,0xAA,0x00,0xBD,0xCE,0x0B);
60 DEFINE_GUID(CLSID_JSProtocol, 0x3050F3B2, 0x98B5, 0x11CF, 0xBB,0x82, 0x00,0xAA,0x00,0xBD,0xCE,0x0B);
61
62 DEFINE_EXPECT(GetBindInfo);
63 DEFINE_EXPECT(ReportProgress);
64 DEFINE_EXPECT(ReportData);
65 DEFINE_EXPECT(ReportResult);
66
67 static HRESULT expect_hrResult;
68 static BOOL expect_hr_win32err = FALSE;
69 static DWORD bindf;
70
71 static const WCHAR about_blank_url[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
72 static const WCHAR about_test_url[] = {'a','b','o','u','t',':','t','e','s','t',0};
73 static const WCHAR about_res_url[] = {'r','e','s',':','b','l','a','n','k',0};
74 static const WCHAR javascript_test_url[] = {'j','a','v','a','s','c','r','i','p','t',':','t','e','s','t','(',')',0};
75
76 static const char *debugstr_guid(REFIID riid)
77 {
78     static char buf[50];
79
80     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
81             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
82             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
83             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
84
85     return buf;
86 }
87
88 static HRESULT WINAPI ProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
89 {
90     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
91         *ppv = iface;
92         return S_OK;
93     }
94
95     *ppv = NULL;
96     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
97     return E_NOINTERFACE;
98 }
99
100 static ULONG WINAPI ProtocolSink_AddRef(IInternetProtocolSink *iface)
101 {
102     return 2;
103 }
104
105 static ULONG WINAPI ProtocolSink_Release(IInternetProtocolSink *iface)
106 {
107     return 1;
108 }
109
110 static HRESULT WINAPI ProtocolSink_Switch(IInternetProtocolSink *iface, PROTOCOLDATA *pProtocolData)
111 {
112     ok(0, "unexpected call\n");
113     return E_NOTIMPL;
114 }
115
116 static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface, ULONG ulStatusCode,
117         LPCWSTR szStatusText)
118 {
119     static const WCHAR text_html[] = {'t','e','x','t','/','h','t','m','l',0};
120
121     CHECK_EXPECT(ReportProgress);
122
123     ok(ulStatusCode == BINDSTATUS_MIMETYPEAVAILABLE
124             || ulStatusCode == BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE,
125             "ulStatusCode=%d\n", ulStatusCode);
126     ok(!lstrcmpW(szStatusText, text_html), "szStatusText != text/html\n");
127
128     return S_OK;
129 }
130
131 static HRESULT WINAPI ProtocolSink_ReportData(IInternetProtocolSink *iface, DWORD grfBSCF, ULONG ulProgress,
132         ULONG ulProgressMax)
133 {
134     CHECK_EXPECT(ReportData);
135
136     ok(ulProgress == ulProgressMax, "ulProgress != ulProgressMax\n");
137     ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE),
138             "grcf = %08x\n", grfBSCF);
139
140     return S_OK;
141 }
142
143 static HRESULT WINAPI ProtocolSink_ReportResult(IInternetProtocolSink *iface, HRESULT hrResult, DWORD dwError,
144         LPCWSTR szResult)
145 {
146     CHECK_EXPECT(ReportResult);
147
148     if(expect_hr_win32err)
149         ok((hrResult&0xffff0000) == ((FACILITY_WIN32 << 16)|0x80000000) || expect_hrResult,
150                 "expected win32 err or %08x got: %08x\n", expect_hrResult, hrResult);
151     else
152         ok(hrResult == expect_hrResult || ((expect_hrResult == E_INVALIDARG ||
153            expect_hrResult == HRESULT_FROM_WIN32(ERROR_RESOURCE_TYPE_NOT_FOUND)) &&
154            hrResult == MK_E_SYNTAX), "expected: %08x got: %08x\n", expect_hrResult, hrResult);
155     ok(dwError == 0, "dwError = %d\n", dwError);
156     ok(!szResult, "szResult != NULL\n");
157
158     return S_OK;
159 }
160
161 static IInternetProtocolSinkVtbl protocol_sink_vtbl = {
162     ProtocolSink_QueryInterface,
163     ProtocolSink_AddRef,
164     ProtocolSink_Release,
165     ProtocolSink_Switch,
166     ProtocolSink_ReportProgress,
167     ProtocolSink_ReportData,
168     ProtocolSink_ReportResult
169 };
170
171 static IInternetProtocolSink protocol_sink = {
172     &protocol_sink_vtbl
173 };
174
175 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface, REFIID riid, void **ppv)
176 {
177     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetBindInfo, riid)) {
178         *ppv = iface;
179         return S_OK;
180     }
181
182     *ppv = NULL;
183     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
184     return E_NOINTERFACE;
185 }
186
187 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
188 {
189     return 2;
190 }
191
192 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
193 {
194     return 1;
195 }
196
197 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
198 {
199     CHECK_EXPECT(GetBindInfo);
200
201     ok(grfBINDF != NULL, "grfBINDF == NULL\n");
202     ok(pbindinfo != NULL, "pbindinfo == NULL\n");
203     ok(pbindinfo->cbSize == sizeof(BINDINFO), "wrong size of pbindinfo: %d\n", pbindinfo->cbSize);
204
205     *grfBINDF = bindf;
206     return S_OK;
207 }
208
209 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface, ULONG ulStringType, LPOLESTR *ppwzStr,
210         ULONG cEl, ULONG *pcElFetched)
211 {
212     ok(0, "unexpected call\n");
213     return E_NOTIMPL;
214 }
215
216 static IInternetBindInfoVtbl bind_info_vtbl = {
217     BindInfo_QueryInterface,
218     BindInfo_AddRef,
219     BindInfo_Release,
220     BindInfo_GetBindInfo,
221     BindInfo_GetBindString
222 };
223
224 static IInternetBindInfo bind_info = {
225     &bind_info_vtbl
226 };
227
228 static void test_protocol_fail(IInternetProtocol *protocol, LPCWSTR url, HRESULT expected_hres,
229         BOOL expect_win32err)
230 {
231     HRESULT hres;
232
233     SET_EXPECT(GetBindInfo);
234     SET_EXPECT(ReportResult);
235
236     expect_hrResult = expected_hres;
237     expect_hr_win32err = expect_win32err;
238     hres = IInternetProtocol_Start(protocol, url, &protocol_sink, &bind_info, 0, 0);
239     if(expect_win32err)
240         ok((hres&0xffff0000) == ((FACILITY_WIN32 << 16)|0x80000000) || hres == expect_hrResult,
241                 "expected win32 err or %08x got: %08x\n", expected_hres, hres);
242     else
243         ok(hres == expected_hres || ((expected_hres == E_INVALIDARG ||
244            expected_hres == HRESULT_FROM_WIN32(ERROR_RESOURCE_TYPE_NOT_FOUND)) && hres == MK_E_SYNTAX),
245            "expected: %08x got: %08x\n", expected_hres, hres);
246
247     CHECK_CALLED(GetBindInfo);
248     CHECK_CALLED(ReportResult);
249 }
250
251 static void protocol_start(IInternetProtocol *protocol, LPCWSTR url)
252 {
253     HRESULT hres;
254
255     SET_EXPECT(GetBindInfo);
256     SET_EXPECT(ReportResult);
257     SET_EXPECT(ReportProgress);
258     SET_EXPECT(ReportData);
259     expect_hrResult = S_OK;
260     expect_hr_win32err = FALSE;
261
262     hres = IInternetProtocol_Start(protocol, url, &protocol_sink, &bind_info, 0, 0);
263     ok(hres == S_OK, "Start failed: %08x\n", hres);
264
265     CHECK_CALLED(GetBindInfo);
266     CHECK_CALLED(ReportProgress);
267     CHECK_CALLED(ReportData);
268     CHECK_CALLED(ReportResult);
269 }
270
271 static void res_sec_url_cmp(LPCWSTR url, DWORD size, LPCWSTR file)
272 {
273     WCHAR buf[MAX_PATH];
274     DWORD len;
275
276     static const WCHAR fileW[] = {'f','i','l','e',':','/','/'};
277
278     if(size < sizeof(fileW)/sizeof(WCHAR) || memcmp(url, fileW, sizeof(fileW))) {
279         ok(0, "wrong URL protocol\n");
280         return;
281     }
282
283     SetLastError(0xdeadbeef);
284     len = SearchPathW(NULL, file, NULL, sizeof(buf)/sizeof(WCHAR), buf, NULL);
285     if(!len) {
286         if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
287             win_skip("SearchPathW is not implemented\n");
288         else
289             ok(0, "SearchPath failed: %u\n", GetLastError());
290         return;
291     }
292
293     len += sizeof(fileW)/sizeof(WCHAR)+1;
294     ok(len == size, "wrong size %u, expected %u\n", size, len);
295     ok(!lstrcmpW(url + sizeof(fileW)/sizeof(WCHAR), buf), "wrong file part %s\n", wine_dbgstr_w(url));
296 }
297
298 static void test_res_protocol(void)
299 {
300     IInternetProtocolInfo *protocol_info;
301     IUnknown *unk;
302     IClassFactory *factory;
303     HRESULT hres;
304
305     static const WCHAR blank_url[] =
306         {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l','/','b','l','a','n','k','.','h','t','m',0};
307     static const WCHAR test_part_url[] = {'r','e','s',':','/','/','C','S','S','/','t','e','s','t',0};
308     static const WCHAR wrong_url1[] =
309         {'m','s','h','t','m','l','.','d','l','l','/','b','l','a','n','k','.','m','t','h',0};
310     static const WCHAR wrong_url2[] =
311         {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l',0};
312     static const WCHAR wrong_url3[] =
313         {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l','/','x','x','.','h','t','m',0};
314     static const WCHAR wrong_url4[] =
315         {'r','e','s',':','/','/','x','x','.','d','l','l','/','b','l','a','n','k','.','h','t','m',0};
316     static const WCHAR wrong_url5[] =
317         {'r','e','s',':','/','/','s','h','t','m','l','.','d','l','l','/','b','l','a','n','k','.','h','t','m',0};
318     static const WCHAR mshtml_dllW[] = {'m','s','h','t','m','l','.','d','l','l',0};
319
320     hres = CoGetClassObject(&CLSID_ResProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
321     ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
322     if(FAILED(hres))
323         return;
324
325     hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
326     ok(hres == S_OK, "Could not get IInternetProtocolInfo interface: %08x\n", hres);
327     if(SUCCEEDED(hres)) {
328         WCHAR buf[128];
329         DWORD size;
330         int i;
331
332         for(i = PARSE_CANONICALIZE; i <= PARSE_UNESCAPE; i++) {
333             if(i != PARSE_SECURITY_URL && i != PARSE_DOMAIN) {
334                 hres = IInternetProtocolInfo_ParseUrl(protocol_info, blank_url, i, 0, buf,
335                         sizeof(buf)/sizeof(buf[0]), &size, 0);
336                 ok(hres == INET_E_DEFAULT_ACTION,
337                         "[%d] failed: %08x, expected INET_E_DEFAULT_ACTION\n", i, hres);
338             }
339         }
340
341         hres = IInternetProtocolInfo_ParseUrl(protocol_info, blank_url, PARSE_SECURITY_URL, 0, buf,
342                 sizeof(buf)/sizeof(buf[0]), &size, 0);
343         ok(hres == S_OK, "ParseUrl failed: %08x\n", hres);
344         res_sec_url_cmp(buf, size, mshtml_dllW);
345
346         size = 0;
347         hres = IInternetProtocolInfo_ParseUrl(protocol_info, blank_url, PARSE_SECURITY_URL, 0, buf,
348                 3, &size, 0);
349         ok(hres == S_FALSE, "ParseUrl failed: %08x, expected S_FALSE\n", hres);
350         ok(size, "size=0\n");
351
352         hres = IInternetProtocolInfo_ParseUrl(protocol_info, wrong_url1, PARSE_SECURITY_URL, 0, buf,
353                 sizeof(buf)/sizeof(buf[0]), &size, 0);
354         ok(hres == MK_E_SYNTAX || hres == E_INVALIDARG,
355            "ParseUrl failed: %08x, expected MK_E_SYNTAX\n", hres);
356
357         hres = IInternetProtocolInfo_ParseUrl(protocol_info, wrong_url5, PARSE_SECURITY_URL, 0, buf,
358                 sizeof(buf)/sizeof(buf[0]), &size, 0);
359         ok(hres == MK_E_SYNTAX, "ParseUrl failed: %08x, expected MK_E_SYNTAX\n", hres);
360
361         size = 0xdeadbeef;
362         buf[0] = '?';
363         hres = IInternetProtocolInfo_ParseUrl(protocol_info, blank_url, PARSE_DOMAIN, 0, buf,
364                 sizeof(buf)/sizeof(buf[0]), &size, 0);
365         ok(hres == S_OK || hres == E_FAIL, "ParseUrl failed: %08x\n", hres);
366         ok(buf[0] == '?', "buf changed\n");
367         ok(size == sizeof(blank_url)/sizeof(WCHAR) ||
368            size == sizeof(buf)/sizeof(buf[0]), /* IE8 */
369            "size=%d\n", size);
370
371         size = 0xdeadbeef;
372         hres = IInternetProtocolInfo_ParseUrl(protocol_info, wrong_url1, PARSE_DOMAIN, 0, buf,
373                 sizeof(buf)/sizeof(buf[0]), &size, 0);
374         ok(hres == S_OK || hres == E_FAIL, "ParseUrl failed: %08x\n", hres);
375         ok(buf[0] == '?', "buf changed\n");
376         ok(size == sizeof(wrong_url1)/sizeof(WCHAR) ||
377            size == sizeof(buf)/sizeof(buf[0]), /* IE8 */
378            "size=%d\n", size);
379
380         if (0)
381         {
382         /* Crashes on win9x */
383         size = 0xdeadbeef;
384         buf[0] = '?';
385         hres = IInternetProtocolInfo_ParseUrl(protocol_info, NULL, PARSE_DOMAIN, 0, buf,
386                 sizeof(buf)/sizeof(buf[0]), &size, 0);
387         ok(hres == E_FAIL, "ParseUrl failed: %08x\n", hres);
388         ok(buf[0] == '?', "buf changed\n");
389         ok(size == 1, "size=%u, expected 1\n", size);
390
391         buf[0] = '?';
392         hres = IInternetProtocolInfo_ParseUrl(protocol_info, blank_url, PARSE_DOMAIN, 0, buf,
393                 sizeof(buf)/sizeof(buf[0]), NULL, 0);
394         ok(hres == E_POINTER, "ParseUrl failed: %08x\n", hres);
395         ok(buf[0] == '?', "buf changed\n");
396
397         buf[0] = '?';
398         hres = IInternetProtocolInfo_ParseUrl(protocol_info, NULL, PARSE_DOMAIN, 0, buf,
399                 sizeof(buf)/sizeof(buf[0]), NULL, 0);
400         ok(hres == E_POINTER, "ParseUrl failed: %08x\n", hres);
401         ok(buf[0] == '?', "buf changed\n");
402         }
403
404         buf[0] = '?';
405         hres = IInternetProtocolInfo_ParseUrl(protocol_info, blank_url, PARSE_UNESCAPE+1, 0, buf,
406                 sizeof(buf)/sizeof(buf[0]), &size, 0);
407         ok(hres == INET_E_DEFAULT_ACTION,
408                 "ParseUrl failed: %08x, expected INET_E_DEFAULT_ACTION\n", hres);
409         ok(buf[0] == '?', "buf changed\n");
410
411         size = 0xdeadbeef;
412         hres = IInternetProtocolInfo_CombineUrl(protocol_info, blank_url, test_part_url,
413                 0, buf, sizeof(buf)/sizeof(buf[0]), &size, 0);
414         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
415         ok(size == 0xdeadbeef, "size=%d\n", size);
416
417         size = 0xdeadbeef;
418         hres = IInternetProtocolInfo_CombineUrl(protocol_info, blank_url, test_part_url,
419                 URL_FILE_USE_PATHURL, buf, sizeof(buf)/sizeof(buf[0]), &size, 0);
420         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
421         ok(size == 0xdeadbeef, "size=%d\n", size);
422
423         size = 0xdeadbeef;
424         hres = IInternetProtocolInfo_CombineUrl(protocol_info, NULL, NULL,
425                 URL_FILE_USE_PATHURL, NULL, 0xdeadbeef, NULL, 0);
426         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
427         ok(size == 0xdeadbeef, "size=%d\n", size);
428
429         hres = IInternetProtocolInfo_CompareUrl(protocol_info, blank_url, blank_url, 0);
430         ok(hres == E_NOTIMPL, "CompareUrl failed: %08x\n", hres);
431
432         hres = IInternetProtocolInfo_CompareUrl(protocol_info, NULL, NULL, 0xdeadbeef);
433         ok(hres == E_NOTIMPL, "CompareUrl failed: %08x\n", hres);
434
435         for(i=0; i<30; i++) {
436             if(i == QUERY_USES_NETWORK || i == QUERY_IS_SECURE || i == QUERY_IS_SAFE)
437                 continue;
438
439             hres = IInternetProtocolInfo_QueryInfo(protocol_info, blank_url, i, 0,
440                                                    buf, sizeof(buf), &size, 0);
441             ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER,
442                "QueryInfo(%d) returned: %08x, expected INET_E_USE_DEFAULT_PROTOCOLHANDLER\n", i, hres);
443         }
444
445         size = 0xdeadbeef;
446         memset(buf, '?', sizeof(buf));
447         hres = IInternetProtocolInfo_QueryInfo(protocol_info, blank_url, QUERY_USES_NETWORK, 0,
448                                                buf, sizeof(buf), &size, 0);
449         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
450         ok(size == sizeof(DWORD), "size=%d\n", size);
451         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
452
453         memset(buf, '?', sizeof(buf));
454         hres = IInternetProtocolInfo_QueryInfo(protocol_info, blank_url, QUERY_USES_NETWORK, 0,
455                                                buf, sizeof(buf), NULL, 0);
456         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
457         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
458
459         hres = IInternetProtocolInfo_QueryInfo(protocol_info, blank_url, QUERY_USES_NETWORK, 0,
460                                                buf, 3, &size, 0);
461         ok(hres == E_FAIL, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
462
463         size = 0xdeadbeef;
464         memset(buf, '?', sizeof(buf));
465         hres = IInternetProtocolInfo_QueryInfo(protocol_info, NULL, QUERY_USES_NETWORK, 0,
466                                                buf, sizeof(buf), &size, 0);
467         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
468         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
469         ok(size == sizeof(DWORD), "size=%d\n", size);
470         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
471
472         hres = IInternetProtocolInfo_QueryInfo(protocol_info, blank_url, QUERY_USES_NETWORK, 0,
473                                                NULL, sizeof(buf), &size, 0);
474         ok(hres == E_FAIL, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
475
476         hres = IInternetProtocolInfo_QueryInfo(protocol_info, blank_url, 60, 0,
477                                                NULL, sizeof(buf), &size, 0);
478         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER,
479            "QueryInfo failed: %08x, expected INET_E_USE_DEFAULT_PROTOCOLHANDLER\n", hres);
480
481         IInternetProtocolInfo_Release(protocol_info);
482     }
483
484     hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
485     ok(hres == S_OK, "Could not get IClassFactory interface\n");
486     if(SUCCEEDED(hres)) {
487         IInternetProtocol *protocol;
488         BYTE buf[512];
489         ULONG cb;
490         hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
491         ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
492
493         if(SUCCEEDED(hres)) {
494             IInternetPriority *priority;
495
496             hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
497             ok(hres == E_NOINTERFACE,
498                "QueryInterface(IInternetPriority) returned %08x, expected E_NOINTEFACE\n", hres);
499
500             test_protocol_fail(protocol, wrong_url1, E_INVALIDARG, FALSE);
501             test_protocol_fail(protocol, wrong_url2,
502                                HRESULT_FROM_WIN32(ERROR_RESOURCE_TYPE_NOT_FOUND), FALSE);
503             test_protocol_fail(protocol, wrong_url3, E_FAIL, TRUE);
504             test_protocol_fail(protocol, wrong_url4, E_FAIL, TRUE);
505
506             cb = 0xdeadbeef;
507             hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
508             ok(hres == E_FAIL, "Read returned %08x expected E_FAIL\n", hres);
509             ok(cb == 0xdeadbeef, "cb=%u expected 0xdeadbeef\n", cb);
510     
511             protocol_start(protocol, blank_url);
512             hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
513             ok(hres == S_OK, "Read failed: %08x\n", hres);
514             ok(cb == 2, "cb=%u expected 2\n", cb);
515             hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
516             ok(hres == S_OK, "Read failed: %08x\n", hres);
517             hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
518             ok(hres == S_FALSE, "Read failed: %08x expected S_FALSE\n", hres);
519             ok(cb == 0, "cb=%u expected 0\n", cb);
520             hres = IInternetProtocol_UnlockRequest(protocol);
521             ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
522
523             protocol_start(protocol, blank_url);
524             hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
525             ok(hres == S_OK, "Read failed: %08x\n", hres);
526             hres = IInternetProtocol_LockRequest(protocol, 0);
527             ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
528             hres = IInternetProtocol_UnlockRequest(protocol);
529             ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
530             hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
531             ok(hres == S_OK, "Read failed: %08x\n", hres);
532
533             protocol_start(protocol, blank_url);
534             hres = IInternetProtocol_LockRequest(protocol, 0);
535             ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
536             hres = IInternetProtocol_Terminate(protocol, 0);
537             ok(hres == S_OK, "Terminate failed: %08x\n", hres);
538             hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
539             ok(hres == S_OK, "Read failed: %08x\n\n", hres);
540             hres = IInternetProtocol_UnlockRequest(protocol);
541             ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
542             hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
543             ok(hres == S_OK, "Read failed: %08x\n", hres);
544             hres = IInternetProtocol_Terminate(protocol, 0);
545             ok(hres == S_OK, "Terminate failed: %08x\n", hres);
546             hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
547             ok(hres == S_OK, "Read failed: %08x\n", hres);
548             ok(cb == 2, "cb=%u expected 2\n", cb);
549
550             protocol_start(protocol, blank_url);
551             hres = IInternetProtocol_LockRequest(protocol, 0);
552             ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
553             hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
554             ok(hres == S_OK, "Read failed: %08x\n", hres);
555             protocol_start(protocol, blank_url);
556             hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
557             ok(hres == S_OK, "Read failed: %08x\n", hres);
558             hres = IInternetProtocol_Terminate(protocol, 0);
559             ok(hres == S_OK, "Terminate failed: %08x\n", hres);
560
561             IInternetProtocol_Release(protocol);
562         }
563
564         IClassFactory_Release(factory);
565     }
566
567     IUnknown_Release(unk);
568 }
569
570 static void do_test_about_protocol(IClassFactory *factory, DWORD bf)
571 {
572     IInternetProtocol *protocol;
573     IInternetPriority *priority;
574     BYTE buf[512];
575     ULONG cb;
576     HRESULT hres;
577
578     static const WCHAR blank_html[] = {0xfeff,'<','H','T','M','L','>','<','/','H','T','M','L','>',0};
579     static const WCHAR test_html[] =
580         {0xfeff,'<','H','T','M','L','>','t','e','s','t','<','/','H','T','M','L','>',0};
581
582     bindf = bf;
583
584     hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
585     ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
586     if(FAILED(hres))
587         return;
588
589     hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
590     ok(hres == E_NOINTERFACE,
591        "QueryInterface(IInternetPriority) returned %08x, expected E_NOINTEFACE\n", hres);
592
593     protocol_start(protocol, about_blank_url);
594     hres = IInternetProtocol_LockRequest(protocol, 0);
595     ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
596     hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
597     ok(hres == S_OK, "Read failed: %08x\n", hres);
598     ok(cb == sizeof(blank_html), "cb=%d\n", cb);
599     ok(!memcmp(buf, blank_html, cb), "Readed wrong data\n");
600     hres = IInternetProtocol_UnlockRequest(protocol);
601     ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
602
603     protocol_start(protocol, about_test_url);
604     hres = IInternetProtocol_LockRequest(protocol, 0);
605     ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
606     hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
607     ok(hres == S_OK, "Read failed: %08x\n", hres);
608     ok(cb == sizeof(test_html), "cb=%d\n", cb);
609     ok(!memcmp(buf, test_html, cb), "Readed wrong data\n");
610     hres = IInternetProtocol_UnlockRequest(protocol);
611     ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
612
613     protocol_start(protocol, about_res_url);
614     hres = IInternetProtocol_LockRequest(protocol, 0);
615     ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
616     hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
617     ok(hres == S_OK, "Read failed: %08x\n", hres);
618     ok(cb == sizeof(blank_html), "cb=%d\n", cb);
619     ok(!memcmp(buf, blank_html, cb), "Readed wrong data\n");
620     hres = IInternetProtocol_UnlockRequest(protocol);
621     ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
622
623     IInternetProtocol_Release(protocol);
624 }
625
626 static void test_about_protocol(void)
627 {
628     IInternetProtocolInfo *protocol_info;
629     IUnknown *unk;
630     IClassFactory *factory;
631     HRESULT hres;
632
633     hres = CoGetClassObject(&CLSID_AboutProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
634     ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
635     if(FAILED(hres))
636         return;
637
638     hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
639     ok(hres == S_OK, "Could not get IInternetProtocolInfo interface: %08x\n", hres);
640     if(SUCCEEDED(hres)) {
641         WCHAR buf[128];
642         DWORD size;
643         int i;
644
645         for(i = PARSE_CANONICALIZE; i <= PARSE_UNESCAPE; i++) {
646             if(i != PARSE_SECURITY_URL && i != PARSE_DOMAIN) {
647                 hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_blank_url, i, 0, buf,
648                         sizeof(buf)/sizeof(buf[0]), &size, 0);
649                 ok(hres == INET_E_DEFAULT_ACTION,
650                         "[%d] failed: %08x, expected INET_E_DEFAULT_ACTION\n", i, hres);
651             }
652         }
653
654         hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_blank_url, PARSE_SECURITY_URL, 0, buf,
655                 sizeof(buf)/sizeof(buf[0]), &size, 0);
656         ok(hres == S_OK, "ParseUrl failed: %08x\n", hres);
657         ok(!lstrcmpW(about_blank_url, buf), "buf != blank_url\n");
658
659         hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_blank_url, PARSE_SECURITY_URL, 0, buf,
660                 3, &size, 0);
661         ok(hres == S_FALSE, "ParseUrl failed: %08x, expected S_FALSE\n", hres);
662
663         hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_test_url, PARSE_SECURITY_URL, 0, buf,
664                 sizeof(buf)/sizeof(buf[0]), &size, 0);
665         ok(hres == S_OK, "ParseUrl failed: %08x\n", hres);
666         ok(!lstrcmpW(about_test_url, buf), "buf != test_url\n");
667
668         size = 0xdeadbeef;
669         buf[0] = '?';
670         hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_blank_url, PARSE_DOMAIN, 0, buf,
671                 sizeof(buf)/sizeof(buf[0]), &size, 0);
672         ok(hres == S_OK || hres == E_FAIL, "ParseUrl failed: %08x\n", hres);
673         ok(buf[0] == '?', "buf changed\n");
674         ok(size == sizeof(about_blank_url)/sizeof(WCHAR) ||
675            size == sizeof(buf)/sizeof(buf[0]), /* IE8 */
676            "size=%d\n", size);
677
678         if (0)
679         {
680         /* Crashes on win9x */
681         size = 0xdeadbeef;
682         buf[0] = '?';
683         hres = IInternetProtocolInfo_ParseUrl(protocol_info, NULL, PARSE_DOMAIN, 0, buf,
684                 sizeof(buf)/sizeof(buf[0]), &size, 0);
685         ok(hres == E_FAIL, "ParseUrl failed: %08x\n", hres);
686         ok(buf[0] == '?', "buf changed\n");
687         ok(size == 1, "size=%u, expected 1\n", size);
688
689         buf[0] = '?';
690         hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_blank_url, PARSE_DOMAIN, 0, buf,
691                 sizeof(buf)/sizeof(buf[0]), NULL, 0);
692         ok(hres == E_POINTER, "ParseUrl failed: %08x\n", hres);
693         ok(buf[0] == '?', "buf changed\n");
694
695         buf[0] = '?';
696         hres = IInternetProtocolInfo_ParseUrl(protocol_info, NULL, PARSE_DOMAIN, 0, buf,
697                 sizeof(buf)/sizeof(buf[0]), NULL, 0);
698         ok(hres == E_POINTER, "ParseUrl failed: %08x\n", hres);
699         ok(buf[0] == '?', "buf changed\n");
700         }
701
702         hres = IInternetProtocolInfo_ParseUrl(protocol_info, about_blank_url, PARSE_UNESCAPE+1, 0, buf,
703                 sizeof(buf)/sizeof(buf[0]), &size, 0);
704         ok(hres == INET_E_DEFAULT_ACTION,
705                 "ParseUrl failed: %08x, expected INET_E_DEFAULT_ACTION\n", hres);
706
707         size = 0xdeadbeef;
708         hres = IInternetProtocolInfo_CombineUrl(protocol_info, about_blank_url, about_test_url,
709                 0, buf, sizeof(buf)/sizeof(buf[0]), &size, 0);
710         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
711         ok(size == 0xdeadbeef, "size=%d\n", size);
712
713         size = 0xdeadbeef;
714         hres = IInternetProtocolInfo_CombineUrl(protocol_info, about_blank_url, about_test_url,
715                 URL_FILE_USE_PATHURL, buf, sizeof(buf)/sizeof(buf[0]), &size, 0);
716         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
717         ok(size == 0xdeadbeef, "size=%d\n", size);
718
719         size = 0xdeadbeef;
720         hres = IInternetProtocolInfo_CombineUrl(protocol_info, NULL, NULL,
721                 URL_FILE_USE_PATHURL, buf, sizeof(buf)/sizeof(buf[0]), &size, 0);
722         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
723         ok(size == 0xdeadbeef, "size=%d\n", size);
724
725         hres = IInternetProtocolInfo_CompareUrl(protocol_info, about_blank_url, about_blank_url, 0);
726         ok(hres == E_NOTIMPL, "CompareUrl failed: %08x\n", hres);
727
728         hres = IInternetProtocolInfo_CompareUrl(protocol_info, NULL, NULL, 0xdeadbeef);
729         ok(hres == E_NOTIMPL, "CompareUrl failed: %08x\n", hres);
730
731         for(i=0; i<30; i++) {
732             switch(i) {
733             case QUERY_CAN_NAVIGATE:
734             case QUERY_USES_NETWORK:
735             case QUERY_IS_CACHED:
736             case QUERY_IS_INSTALLEDENTRY:
737             case QUERY_IS_CACHED_OR_MAPPED:
738             case QUERY_IS_SECURE:
739             case QUERY_IS_SAFE:
740             case QUERY_USES_HISTORYFOLDER:
741                 break;
742             default:
743                 hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, i, 0,
744                                                        buf, sizeof(buf), &size, 0);
745                 ok(hres == E_FAIL, "QueryInfo(%d) returned: %08x, expected E_FAIL\n", i, hres);
746             }
747         }
748
749         hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, QUERY_CAN_NAVIGATE, 0,
750                                                buf, sizeof(buf), &size, 0);
751         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER ||
752            hres == E_FAIL, /* win2k */
753            "QueryInfo returned: %08x, expected INET_E_USE_DEFAULT_PROTOCOLHANDLER or E_FAIL\n", hres);
754
755         size = 0xdeadbeef;
756         memset(buf, '?', sizeof(buf));
757         hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, QUERY_USES_NETWORK, 0,
758                                                buf, sizeof(buf), &size, 0);
759         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
760         ok(size == sizeof(DWORD), "size=%d\n", size);
761         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
762
763         memset(buf, '?', sizeof(buf));
764         hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, QUERY_USES_NETWORK, 0,
765                                                buf, sizeof(buf), NULL, 0);
766         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
767         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
768
769         hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, QUERY_USES_NETWORK, 0,
770                                                buf, 3, &size, 0);
771         ok(hres == E_FAIL, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
772
773         hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, QUERY_USES_NETWORK, 0,
774                                                NULL, sizeof(buf), &size, 0);
775         ok(hres == E_FAIL, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
776
777         hres = IInternetProtocolInfo_QueryInfo(protocol_info, about_blank_url, 60, 0,
778                                                NULL, sizeof(buf), &size, 0);
779         ok(hres == E_FAIL, "QueryInfo failed: %08x, expected E_FAIL\n", hres);
780
781         IInternetProtocolInfo_Release(protocol_info);
782     }
783
784     hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
785     ok(hres == S_OK, "Could not get IClassFactory interface\n");
786     if(SUCCEEDED(hres)) {
787         do_test_about_protocol(factory, 0);
788         do_test_about_protocol(factory,
789                 BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NEEDFILE);
790
791         IClassFactory_Release(factory);
792     }
793
794     IUnknown_Release(unk);
795 }
796
797 static void test_javascript_protocol(void)
798 {
799     IInternetProtocolInfo *protocol_info;
800     IUnknown *unk;
801     IClassFactory *factory;
802     HRESULT hres;
803
804     hres = CoGetClassObject(&CLSID_JSProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
805     ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
806     if(FAILED(hres))
807         return;
808
809     hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
810     ok(hres == S_OK, "Could not get IInternetProtocolInfo interface: %08x\n", hres);
811     if(SUCCEEDED(hres)) {
812         WCHAR buf[128];
813         DWORD size;
814         int i;
815
816         for(i = PARSE_CANONICALIZE; i <= PARSE_UNESCAPE; i++) {
817             if(i != PARSE_SECURITY_URL && i != PARSE_DOMAIN) {
818                 hres = IInternetProtocolInfo_ParseUrl(protocol_info, javascript_test_url, i, 0, buf,
819                         sizeof(buf)/sizeof(buf[0]), &size, 0);
820                 ok(hres == INET_E_DEFAULT_ACTION,
821                         "[%d] failed: %08x, expected INET_E_DEFAULT_ACTION\n", i, hres);
822             }
823         }
824
825         hres = IInternetProtocolInfo_ParseUrl(protocol_info, javascript_test_url, PARSE_UNESCAPE+1, 0, buf,
826                 sizeof(buf)/sizeof(buf[0]), &size, 0);
827         ok(hres == INET_E_DEFAULT_ACTION,
828                 "ParseUrl failed: %08x, expected INET_E_DEFAULT_ACTION\n", hres);
829
830         size = 0xdeadbeef;
831         hres = IInternetProtocolInfo_CombineUrl(protocol_info, javascript_test_url, javascript_test_url,
832                 0, buf, sizeof(buf)/sizeof(buf[0]), &size, 0);
833         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER, "CombineUrl failed: %08x\n", hres);
834         ok(size == 0xdeadbeef, "size=%d\n", size);
835
836         hres = IInternetProtocolInfo_CompareUrl(protocol_info, javascript_test_url, javascript_test_url, 0);
837         ok(hres == E_NOTIMPL, "CompareUrl failed: %08x\n", hres);
838
839         for(i=0; i<30; i++) {
840             switch(i) {
841             case QUERY_USES_NETWORK:
842             case QUERY_IS_SECURE:
843                 break;
844             default:
845                 hres = IInternetProtocolInfo_QueryInfo(protocol_info, javascript_test_url, i, 0,
846                                                        buf, sizeof(buf), &size, 0);
847                 ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER,
848                    "QueryInfo(%d) returned: %08x, expected INET_E_USE_DEFAULT_PROTOCOLHANDLER\n", i, hres);
849             }
850         }
851
852
853         memset(buf, '?', sizeof(buf));
854         hres = IInternetProtocolInfo_QueryInfo(protocol_info, javascript_test_url, QUERY_USES_NETWORK, 0,
855                                                buf, sizeof(buf), &size, 0);
856         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
857         ok(size == sizeof(DWORD), "size=%d\n", size);
858         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
859
860         memset(buf, '?', sizeof(buf));
861         hres = IInternetProtocolInfo_QueryInfo(protocol_info, javascript_test_url, QUERY_USES_NETWORK, 0,
862                                                buf, sizeof(buf), NULL, 0);
863         ok(hres == S_OK, "QueryInfo(QUERY_USES_NETWORK) failed: %08x\n", hres);
864         ok(!*(DWORD*)buf, "buf=%d\n", *(DWORD*)buf);
865
866         hres = IInternetProtocolInfo_QueryInfo(protocol_info, javascript_test_url, QUERY_USES_NETWORK, 0,
867                                                buf, 3, &size, 0);
868         ok(hres == E_FAIL, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
869
870         hres = IInternetProtocolInfo_QueryInfo(protocol_info, javascript_test_url, QUERY_USES_NETWORK, 0,
871                                                NULL, sizeof(buf), &size, 0);
872         ok(hres == E_FAIL, "QueryInfo(QUERY_USES_NETWORK) failed: %08x, expected E_FAIL\n", hres);
873
874         hres = IInternetProtocolInfo_QueryInfo(protocol_info, javascript_test_url, 60, 0,
875                                                NULL, sizeof(buf), &size, 0);
876         ok(hres == INET_E_USE_DEFAULT_PROTOCOLHANDLER,
877            "QueryInfo failed: %08x, expected INET_E_USE_DEFAULT_PROTOCOLHANDLER\n", hres);
878
879         /* FIXME: test QUERY_IS_SECURE */
880
881         IInternetProtocolInfo_Release(protocol_info);
882     }
883
884     hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
885     ok(hres == S_OK, "Could not get IClassFactory interface\n");
886     if(SUCCEEDED(hres))
887         IClassFactory_Release(factory);
888
889     IUnknown_Release(unk);
890 }
891
892 START_TEST(protocol)
893 {
894     OleInitialize(NULL);
895
896     test_res_protocol();
897     test_about_protocol();
898     test_javascript_protocol();
899
900     OleUninitialize();
901 }