?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Changes from running autconf after previous patch.
[wine/hacks.git] / dlls / mshtml / tests / script.c
blob23f1ab861c7cf986f491de272510574d232b7390
1 /*
2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
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 #define CONST_VTABLE
21
22 #include <wine/test.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "ole2.h"
29 #include "wininet.h"
30 #include "docobj.h"
31 #include "dispex.h"
32 #include "hlink.h"
33 #include "mshtml.h"
34 #include "mshtmhst.h"
35 #include "initguid.h"
36 #include "activscp.h"
37 #include "activdbg.h"
38 #include "objsafe.h"
39 #include "mshtmdid.h"
40 #include "mshtml_test.h"
41
42 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
43
44 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */
45 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
46 {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
47
48 #ifdef _WIN64
49
50 #define CTXARG_T DWORDLONG
51 #define IActiveScriptParseVtbl IActiveScriptParse64Vtbl
52 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_64Vtbl
53
54 #else
55
56 #define CTXARG_T DWORD
57 #define IActiveScriptParseVtbl IActiveScriptParse32Vtbl
58 #define IActiveScriptParseProcedure2Vtbl IActiveScriptParseProcedure2_32Vtbl
59
60 #endif
61
62 #define DEFINE_EXPECT(func) \
63 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
64
65 #define SET_EXPECT(func) \
66 do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
67
68 #define CHECK_EXPECT2(func) \
69 do { \
70 ok(expect_ ##func, "unexpected call " #func "\n"); \
71 called_ ## func = TRUE; \
72 }while(0)
73
74 #define CHECK_EXPECT(func) \
75 do { \
76 CHECK_EXPECT2(func); \
77 expect_ ## func = FALSE; \
78 }while(0)
79
80 #define CHECK_CALLED(func) \
81 do { \
82 ok(called_ ## func, "expected " #func "\n"); \
83 expect_ ## func = called_ ## func = FALSE; \
84 }while(0)
85
86 #define CHECK_CALLED_BROKEN(func) \
87 do { \
88 ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
89 expect_ ## func = called_ ## func = FALSE; \
90 }while(0)
91
92 #define CHECK_NOT_CALLED(func) \
93 do { \
94 ok(!called_ ## func, "unexpected " #func "\n"); \
95 expect_ ## func = called_ ## func = FALSE; \
96 }while(0)
97
98 #define CLEAR_CALLED(func) \
99 expect_ ## func = called_ ## func = FALSE
100
101
102 DEFINE_EXPECT(CreateInstance);
103 DEFINE_EXPECT(GetInterfaceSafetyOptions);
104 DEFINE_EXPECT(SetInterfaceSafetyOptions);
105 DEFINE_EXPECT(InitNew);
106 DEFINE_EXPECT(Close);
107 DEFINE_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
108 DEFINE_EXPECT(SetProperty_INVOKEVERSIONING);
109 DEFINE_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
110 DEFINE_EXPECT(SetScriptSite);
111 DEFINE_EXPECT(GetScriptState);
112 DEFINE_EXPECT(SetScriptState_STARTED);
113 DEFINE_EXPECT(SetScriptState_CONNECTED);
114 DEFINE_EXPECT(SetScriptState_DISCONNECTED);
115 DEFINE_EXPECT(AddNamedItem);
116 DEFINE_EXPECT(ParseScriptText);
117 DEFINE_EXPECT(GetScriptDispatch);
118 DEFINE_EXPECT(funcDisp);
119 DEFINE_EXPECT(script_divid_d);
120 DEFINE_EXPECT(script_testprop_d);
121 DEFINE_EXPECT(script_testprop_i);
122 DEFINE_EXPECT(script_testprop2_d);
123 DEFINE_EXPECT(AXQueryInterface_IActiveScript);
124 DEFINE_EXPECT(AXQueryInterface_IObjectSafety);
125 DEFINE_EXPECT(AXGetInterfaceSafetyOptions);
126 DEFINE_EXPECT(AXSetInterfaceSafetyOptions_IDispatch);
127 DEFINE_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
128 DEFINE_EXPECT(external_success);
129
130 #define TESTSCRIPT_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80746}"
131 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7faf80646}"
132
133 #define DISPID_SCRIPT_TESTPROP 0x100000
134 #define DISPID_SCRIPT_TESTPROP2 0x100001
135
136 #define DISPID_EXTERNAL_OK 0x300000
137 #define DISPID_EXTERNAL_TRACE 0x300001
138 #define DISPID_EXTERNAL_REPORTSUCCESS 0x300002
139
140 static const GUID CLSID_TestScript =
141 {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x07,0x46}};
142 static const GUID CLSID_TestActiveX =
143 {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
144
145 static IHTMLDocument2 *notif_doc;
146 static IOleDocumentView *view;
147 static IDispatchEx *window_dispex;
148 static BOOL doc_complete;
149 static IDispatch *script_disp;
150 static BOOL ax_objsafe;
151 static HWND container_hwnd;
152 static HRESULT ax_getopt_hres = S_OK, ax_setopt_dispex_hres = S_OK, ax_setopt_disp_hres = S_OK;
153 static DWORD ax_setopt;
154
155 static const char *debugstr_guid(REFIID riid)
156 {
157 static char buf[50];
158
159 sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
160 riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
161 riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
162 riid->Data4[5], riid->Data4[6], riid->Data4[7]);
163
164 return buf;
165 }
166
167 static int strcmp_wa(LPCWSTR strw, const char *stra)
168 {
169 CHAR buf[512];
170 WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
171 return lstrcmpA(stra, buf);
172 }
173
174 static BSTR a2bstr(const char *str)
175 {
176 BSTR ret;
177 int len;
178
179 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
180 ret = SysAllocStringLen(NULL, len);
181 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
182
183 return ret;
184 }
185
186 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
187 {
188 HKEY hkey;
189 DWORD res;
190
191 if(!init) {
192 RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
193 return TRUE;
194 }
195
196 res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
197 if(res != ERROR_SUCCESS)
198 return FALSE;
199
200 if(def_value)
201 res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
202
203 RegCloseKey(hkey);
204
205 return res == ERROR_SUCCESS;
206 }
207
208 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
209 REFIID riid, void**ppv)
210 {
211 if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
212 *ppv = iface;
213 return S_OK;
214 }
215
216 return E_NOINTERFACE;
217 }
218
219 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
220 {
221 return 2;
222 }
223
224 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
225 {
226 return 1;
227 }
228
229 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
230 {
231 if(dispID == DISPID_READYSTATE){
232 BSTR state;
233 HRESULT hres;
234
235 static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
236
237 hres = IHTMLDocument2_get_readyState(notif_doc, &state);
238 ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
239
240 if(!lstrcmpW(state, completeW))
241 doc_complete = TRUE;
242
243 SysFreeString(state);
244 }
245
246 return S_OK;
247 }
248
249 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
250 {
251 ok(0, "unexpected call\n");
252 return E_NOTIMPL;
253 }
254
255 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
256 PropertyNotifySink_QueryInterface,
257 PropertyNotifySink_AddRef,
258 PropertyNotifySink_Release,
259 PropertyNotifySink_OnChanged,
260 PropertyNotifySink_OnRequestEdit
261 };
262
263 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
264
265 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
266 {
267 *ppv = NULL;
268
269 if(IsEqualGUID(riid, &IID_IUnknown)
270 || IsEqualGUID(riid, &IID_IDispatch)
271 || IsEqualGUID(riid, &IID_IDispatchEx))
272 *ppv = iface;
273 else
274 return E_NOINTERFACE;
275
276 return S_OK;
277 }
278
279 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
280 {
281 return 2;
282 }
283
284 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
285 {
286 return 1;
287 }
288
289 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
290 {
291 ok(0, "unexpected call\n");
292 return E_NOTIMPL;
293 }
294
295 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
296 LCID lcid, ITypeInfo **ppTInfo)
297 {
298 ok(0, "unexpected call\n");
299 return E_NOTIMPL;
300 }
301
302 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
303 LPOLESTR *rgszNames, UINT cNames,
304 LCID lcid, DISPID *rgDispId)
305 {
306 ok(0, "unexpected call\n");
307 return E_NOTIMPL;
308 }
309
310 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
311 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
312 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
313 {
314 ok(0, "unexpected call\n");
315 return E_NOTIMPL;
316 }
317
318 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
319 {
320 ok(0, "unexpected call %s %x\n", wine_dbgstr_w(bstrName), grfdex);
321 return E_NOTIMPL;
322 }
323
324 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
325 {
326 ok(0, "unexpected call\n");
327 return E_NOTIMPL;
328 }
329
330 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
331 {
332 ok(0, "unexpected call\n");
333 return E_NOTIMPL;
334 }
335
336 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
337 {
338 ok(0, "unexpected call\n");
339 return E_NOTIMPL;
340 }
341
342 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
343 {
344 ok(0, "unexpected call\n");
345 return E_NOTIMPL;
346 }
347
348 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
349 {
350 ok(0, "unexpected call\n");
351 return E_NOTIMPL;
352 }
353
354 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
355 {
356 ok(0, "unexpected call\n");
357 return E_NOTIMPL;
358 }
359
360 static HRESULT WINAPI funcDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
361 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
362 {
363 CHECK_EXPECT(funcDisp);
364
365 ok(id == DISPID_VALUE, "id = %d\n", id);
366 ok(lcid == 0, "lcid = %x\n", lcid);
367 ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
368 ok(pdp != NULL, "pdp == NULL\n");
369 ok(pdp->cArgs == 2, "pdp->cArgs = %d\n", pdp->cArgs);
370 ok(pdp->cNamedArgs == 1, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
371 ok(pdp->rgdispidNamedArgs[0] == DISPID_THIS, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
372 ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(rgvarg) = %d\n", V_VT(pdp->rgvarg));
373 ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(rgvarg[1]) = %d\n", V_VT(pdp->rgvarg));
374 ok(V_BOOL(pdp->rgvarg+1) == VARIANT_TRUE, "V_BOOL(rgvarg[1]) = %x\n", V_BOOL(pdp->rgvarg));
375 ok(pvarRes != NULL, "pvarRes == NULL\n");
376 ok(pei != NULL, "pei == NULL\n");
377 ok(!pspCaller, "pspCaller != NULL\n");
378
379 V_VT(pvarRes) = VT_I4;
380 V_I4(pvarRes) = 100;
381 return S_OK;
382 }
383
384 static IDispatchExVtbl testObjVtbl = {
385 DispatchEx_QueryInterface,
386 DispatchEx_AddRef,
387 DispatchEx_Release,
388 DispatchEx_GetTypeInfoCount,
389 DispatchEx_GetTypeInfo,
390 DispatchEx_GetIDsOfNames,
391 DispatchEx_Invoke,
392 DispatchEx_GetDispID,
393 funcDisp_InvokeEx,
394 DispatchEx_DeleteMemberByName,
395 DispatchEx_DeleteMemberByDispID,
396 DispatchEx_GetMemberProperties,
397 DispatchEx_GetMemberName,
398 DispatchEx_GetNextDispID,
399 DispatchEx_GetNameSpaceParent
400 };
401
402 static IDispatchEx funcDisp = { &testObjVtbl };
403
404 static HRESULT WINAPI scriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
405 {
406 if(!strcmp_wa(bstrName, "testProp")) {
407 CHECK_EXPECT(script_testprop_d);
408 ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
409 *pid = DISPID_SCRIPT_TESTPROP;
410 return S_OK;
411 }
412
413 if(!strcmp_wa(bstrName, "testProp2")) {
414 CHECK_EXPECT(script_testprop2_d);
415 ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
416 *pid = DISPID_SCRIPT_TESTPROP2;
417 return S_OK;
418 }
419
420 if(!strcmp_wa(bstrName, "divid")) {
421 CHECK_EXPECT(script_divid_d);
422 ok(grfdex == fdexNameCaseSensitive, "grfdex = %x\n", grfdex);
423 return E_FAIL;
424 }
425
426 ok(0, "unexpected call\n");
427 return E_NOTIMPL;
428 }
429
430 static HRESULT WINAPI scriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
431 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
432 {
433 switch(id) {
434 case DISPID_SCRIPT_TESTPROP:
435 CHECK_EXPECT(script_testprop_i);
436
437 ok(lcid == 0, "lcid = %x\n", lcid);
438 ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
439 ok(pdp != NULL, "pdp == NULL\n");
440 ok(pdp->cArgs == 0, "pdp->cArgs = %d\n", pdp->cArgs);
441 ok(pdp->cNamedArgs == 0, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
442 ok(!pdp->rgdispidNamedArgs, "pdp->rgdispidNamedArgs != NULL\n");
443 ok(!pdp->rgvarg, "rgvarg != NULL\n");
444 ok(pvarRes != NULL, "pvarRes == NULL\n");
445 ok(pei != NULL, "pei == NULL\n");
446 ok(!pspCaller, "pspCaller != NULL\n");
447
448 V_VT(pvarRes) = VT_NULL;
449 break;
450 default:
451 ok(0, "unexpected call\n");
452 return E_NOTIMPL;
453 }
454
455 return S_OK;
456 }
457
458 static IDispatchExVtbl scriptDispVtbl = {
459 DispatchEx_QueryInterface,
460 DispatchEx_AddRef,
461 DispatchEx_Release,
462 DispatchEx_GetTypeInfoCount,
463 DispatchEx_GetTypeInfo,
464 DispatchEx_GetIDsOfNames,
465 DispatchEx_Invoke,
466 scriptDisp_GetDispID,
467 scriptDisp_InvokeEx,
468 DispatchEx_DeleteMemberByName,
469 DispatchEx_DeleteMemberByDispID,
470 DispatchEx_GetMemberProperties,
471 DispatchEx_GetMemberName,
472 DispatchEx_GetNextDispID,
473 DispatchEx_GetNameSpaceParent
474 };
475
476 static IDispatchEx scriptDisp = { &scriptDispVtbl };
477
478 static HRESULT WINAPI externalDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
479 {
480 if(!strcmp_wa(bstrName, "ok")) {
481 *pid = DISPID_EXTERNAL_OK;
482 return S_OK;
483 }
484 if(!strcmp_wa(bstrName, "trace")) {
485 *pid = DISPID_EXTERNAL_TRACE;
486 return S_OK;
487 }
488 if(!strcmp_wa(bstrName, "reportSuccess")) {
489 *pid = DISPID_EXTERNAL_REPORTSUCCESS;
490 return S_OK;
491 }
492
493 ok(0, "unexpected name %s\n", wine_dbgstr_w(bstrName));
494 return DISP_E_UNKNOWNNAME;
495 }
496
497 static HRESULT WINAPI externalDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
498 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
499 {
500 switch(id) {
501 case DISPID_EXTERNAL_OK:
502 ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
503 ok(pdp != NULL, "pdp == NULL\n");
504 ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
505 ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
506 ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
507 ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
508 ok(pei != NULL, "pei == NULL\n");
509
510 ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
511 ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg));
512 ok(V_BOOL(pdp->rgvarg+1), "%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
513
514 return S_OK;
515
516 case DISPID_EXTERNAL_TRACE:
517 ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
518 ok(pdp != NULL, "pdp == NULL\n");
519 ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
520 ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
521 ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
522 ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
523 ok(!pvarRes, "pvarRes != NULL\n");
524 ok(pei != NULL, "pei == NULL\n");
525
526 ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
527 if(V_VT(pdp->rgvarg) == VT_BSTR)
528 trace("%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
529
530 return S_OK;
531
532 case DISPID_EXTERNAL_REPORTSUCCESS:
533 CHECK_EXPECT(external_success);
534
535 ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
536 ok(pdp != NULL, "pdp == NULL\n");
537 ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
538 ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
539 ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
540 ok(!pvarRes, "pvarRes != NULL\n");
541 ok(pei != NULL, "pei == NULL\n");
542
543 return S_OK;
544
545 default:
546 ok(0, "unexpected call\n");
547 return E_NOTIMPL;
548 }
549
550 return S_OK;
551 }
552
553 static IDispatchExVtbl externalDispVtbl = {
554 DispatchEx_QueryInterface,
555 DispatchEx_AddRef,
556 DispatchEx_Release,
557 DispatchEx_GetTypeInfoCount,
558 DispatchEx_GetTypeInfo,
559 DispatchEx_GetIDsOfNames,
560 DispatchEx_Invoke,
561 externalDisp_GetDispID,
562 externalDisp_InvokeEx,
563 DispatchEx_DeleteMemberByName,
564 DispatchEx_DeleteMemberByDispID,
565 DispatchEx_GetMemberProperties,
566 DispatchEx_GetMemberName,
567 DispatchEx_GetNextDispID,
568 DispatchEx_GetNameSpaceParent
569 };
570
571 static IDispatchEx externalDisp = { &externalDispVtbl };
572
573 static HRESULT QueryInterface(REFIID,void**);
574
575 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
576 {
577 return QueryInterface(riid, ppv);
578 }
579
580 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
581 {
582 return 2;
583 }
584
585 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
586 {
587 return 1;
588 }
589
590 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
591 IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
592 {
593 return E_NOTIMPL;
594 }
595
596 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
597 {
598 return E_NOTIMPL;
599 }
600
601 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
602 IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
603 IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
604 {
605 return S_OK;
606 }
607
608 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
609 {
610 return S_OK;
611 }
612
613 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
614 {
615 return S_OK;
616 }
617
618 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
619 {
620 return E_NOTIMPL;
621 }
622
623 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
624 {
625 return E_NOTIMPL;
626 }
627
628 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
629 {
630 return S_OK;
631 }
632
633 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
634 IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
635 {
636 return E_NOTIMPL;
637 }
638
639 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
640 const GUID *pguidCmdGroup, DWORD nCmdID)
641 {
642 return E_NOTIMPL;
643 }
644
645 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
646 LPOLESTR *pchKey, DWORD dw)
647 {
648 return S_OK;
649 }
650
651 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
652 IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
653 {
654 return E_NOTIMPL;
655 }
656
657 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
658 {
659 *ppDispatch = (IDispatch*)&externalDisp;
660 return S_OK;
661 }
662
663 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
664 OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
665 {
666 return S_FALSE;
667 }
668
669 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
670 IDataObject **ppPORet)
671 {
672 return E_NOTIMPL;
673 }
674
675 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
676 LPOLESTR *pchKey, DWORD dw)
677 {
678 return E_NOTIMPL;
679 }
680
681 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
682 DocHostUIHandler_QueryInterface,
683 DocHostUIHandler_AddRef,
684 DocHostUIHandler_Release,
685 DocHostUIHandler_ShowContextMenu,
686 DocHostUIHandler_GetHostInfo,
687 DocHostUIHandler_ShowUI,
688 DocHostUIHandler_HideUI,
689 DocHostUIHandler_UpdateUI,
690 DocHostUIHandler_EnableModeless,
691 DocHostUIHandler_OnDocWindowActivate,
692 DocHostUIHandler_OnFrameWindowActivate,
693 DocHostUIHandler_ResizeBorder,
694 DocHostUIHandler_TranslateAccelerator,
695 DocHostUIHandler_GetOptionKeyPath,
696 DocHostUIHandler_GetDropTarget,
697 DocHostUIHandler_GetExternal,
698 DocHostUIHandler_TranslateUrl,
699 DocHostUIHandler_FilterDataObject,
700 DocHostUIHandler_GetOverrideKeyPath
701 };
702
703 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
704
705 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
706 {
707 return E_NOINTERFACE;
708 }
709
710 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
711 {
712 return 2;
713 }
714
715 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
716 {
717 return 1;
718 }
719
720 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
721 {
722 return E_NOTIMPL;
723 }
724
725 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
726 {
727 return E_NOTIMPL;
728 }
729
730 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
731 {
732 return E_NOTIMPL;
733 }
734
735 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
736 LPCBORDERWIDTHS pborderwidths)
737 {
738 return E_NOTIMPL;
739 }
740
741 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
742 LPCBORDERWIDTHS pborderwidths)
743 {
744 return S_OK;
745 }
746
747 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
748 IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
749 {
750 return S_OK;
751 }
752
753 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
754 LPOLEMENUGROUPWIDTHS lpMenuWidths)
755 {
756 return E_NOTIMPL;
757 }
758
759 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
760 HOLEMENU holemenu, HWND hwndActiveObject)
761 {
762 ok(0, "unexpected call\n");
763 return E_NOTIMPL;
764 }
765
766 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
767 {
768 ok(0, "unexpected call\n");
769 return E_NOTIMPL;
770 }
771
772 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
773 {
774 return S_OK;
775 }
776
777 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
778 {
779 return E_NOTIMPL;
780 }
781
782 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
783 {
784 ok(0, "unexpected call\n");
785 return E_NOTIMPL;
786 }
787
788 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
789 InPlaceFrame_QueryInterface,
790 InPlaceFrame_AddRef,
791 InPlaceFrame_Release,
792 InPlaceFrame_GetWindow,
793 InPlaceFrame_ContextSensitiveHelp,
794 InPlaceFrame_GetBorder,
795 InPlaceFrame_RequestBorderSpace,
796 InPlaceFrame_SetBorderSpace,
797 InPlaceFrame_SetActiveObject,
798 InPlaceFrame_InsertMenus,
799 InPlaceFrame_SetMenu,
800 InPlaceFrame_RemoveMenus,
801 InPlaceFrame_SetStatusText,
802 InPlaceFrame_EnableModeless,
803 InPlaceFrame_TranslateAccelerator
804 };
805
806 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
807
808 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
809 {
810 return QueryInterface(riid, ppv);
811 }
812
813 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
814 {
815 return 2;
816 }
817
818 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
819 {
820 return 1;
821 }
822
823 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
824 {
825 *phwnd = container_hwnd;
826 return S_OK;
827 }
828
829 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
830 {
831 ok(0, "unexpected call\n");
832 return E_NOTIMPL;
833 }
834
835 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
836 {
837 return S_OK;
838 }
839
840 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
841 {
842 return S_OK;
843 }
844
845 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
846 {
847 return S_OK;
848 }
849
850 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
851 IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
852 LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
853 {
854 static const RECT rect = {0,0,300,300};
855
856 *ppFrame = &InPlaceFrame;
857 *ppDoc = (IOleInPlaceUIWindow*)&InPlaceFrame;
858 *lprcPosRect = rect;
859 *lprcClipRect = rect;
860
861 lpFrameInfo->cb = sizeof(*lpFrameInfo);
862 lpFrameInfo->fMDIApp = FALSE;
863 lpFrameInfo->hwndFrame = container_hwnd;
864 lpFrameInfo->haccel = NULL;
865 lpFrameInfo->cAccelEntries = 0;
866
867 return S_OK;
868 }
869
870 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
871 {
872 return E_NOTIMPL;
873 }
874
875 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
876 {
877 return S_OK;
878 }
879
880 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
881 {
882 return S_OK;
883 }
884
885 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
886 {
887 return E_NOTIMPL;
888 }
889
890 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
891 {
892 return E_NOTIMPL;
893 }
894
895 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
896 {
897 return E_NOTIMPL;
898 }
899
900 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
901 InPlaceSite_QueryInterface,
902 InPlaceSite_AddRef,
903 InPlaceSite_Release,
904 InPlaceSite_GetWindow,
905 InPlaceSite_ContextSensitiveHelp,
906 InPlaceSite_CanInPlaceActivate,
907 InPlaceSite_OnInPlaceActivate,
908 InPlaceSite_OnUIActivate,
909 InPlaceSite_GetWindowContext,
910 InPlaceSite_Scroll,
911 InPlaceSite_OnUIDeactivate,
912 InPlaceSite_OnInPlaceDeactivate,
913 InPlaceSite_DiscardUndoState,
914 InPlaceSite_DeactivateAndUndo,
915 InPlaceSite_OnPosRectChange,
916 };
917
918 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
919
920 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
921 {
922 return QueryInterface(riid, ppv);
923 }
924
925 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
926 {
927 return 2;
928 }
929
930 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
931 {
932 return 1;
933 }
934
935 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
936 {
937 ok(0, "unexpected call\n");
938 return E_NOTIMPL;
939 }
940
941 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
942 IMoniker **ppmon)
943 {
944 ok(0, "unexpected call\n");
945 return E_NOTIMPL;
946 }
947
948 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
949 {
950 return E_NOTIMPL;
951 }
952
953 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
954 {
955 ok(0, "unexpected call\n");
956 return E_NOTIMPL;
957 }
958
959 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
960 {
961 ok(0, "unexpected call\n");
962 return E_NOTIMPL;
963 }
964
965 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
966 {
967 ok(0, "unexpected call\n");
968 return E_NOTIMPL;
969 }
970
971 static const IOleClientSiteVtbl ClientSiteVtbl = {
972 ClientSite_QueryInterface,
973 ClientSite_AddRef,
974 ClientSite_Release,
975 ClientSite_SaveObject,
976 ClientSite_GetMoniker,
977 ClientSite_GetContainer,
978 ClientSite_ShowObject,
979 ClientSite_OnShowWindow,
980 ClientSite_RequestNewObjectLayout
981 };
982
983 static IOleClientSite ClientSite = { &ClientSiteVtbl };
984
985 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
986 {
987 return QueryInterface(riid, ppv);
988 }
989
990 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
991 {
992 return 2;
993 }
994
995 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
996 {
997 return 1;
998 }
999
1000 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1001 {
1002 RECT rect = {0,0,300,300};
1003 IOleDocument *document;
1004 HRESULT hres;
1005
1006 hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1007 ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1008
1009 hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1010 IOleDocument_Release(document);
1011 ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1012
1013 hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1014 ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1015
1016 hres = IOleDocumentView_UIActivate(view, TRUE);
1017 ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1018
1019 hres = IOleDocumentView_SetRect(view, &rect);
1020 ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1021
1022 hres = IOleDocumentView_Show(view, TRUE);
1023 ok(hres == S_OK, "Show failed: %08x\n", hres);
1024
1025 return S_OK;
1026 }
1027
1028 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1029 DocumentSite_QueryInterface,
1030 DocumentSite_AddRef,
1031 DocumentSite_Release,
1032 DocumentSite_ActivateMe
1033 };
1034
1035 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1036
1037 static HRESULT QueryInterface(REFIID riid, void **ppv)
1038 {
1039 *ppv = NULL;
1040
1041 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1042 *ppv = &ClientSite;
1043 else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1044 *ppv = &DocumentSite;
1045 else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1046 *ppv = &InPlaceSite;
1047 else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1048 *ppv = &DocHostUIHandler;
1049
1050 return *ppv ? S_OK : E_NOINTERFACE;
1051 }
1052
1053 static IHTMLDocument2 *create_document(void)
1054 {
1055 IHTMLDocument2 *doc;
1056 IHTMLDocument5 *doc5;
1057 HRESULT hres;
1058
1059 hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1060 &IID_IHTMLDocument2, (void**)&doc);
1061 ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1062 if (hres != S_OK) return NULL;
1063
1064 hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
1065 if(FAILED(hres)) {
1066 win_skip("Could not get IHTMLDocument5, probably too old IE\n");
1067 IHTMLDocument2_Release(doc);
1068 return NULL;
1069 }
1070
1071 IHTMLDocument5_Release(doc5);
1072 return doc;
1073 }
1074
1075 static void load_string(IHTMLDocument2 *doc, const char *str)
1076 {
1077 IPersistStreamInit *init;
1078 IStream *stream;
1079 HGLOBAL mem;
1080 SIZE_T len;
1081
1082 doc_complete = FALSE;
1083 len = strlen(str);
1084 mem = GlobalAlloc(0, len);
1085 memcpy(mem, str, len);
1086 CreateStreamOnHGlobal(mem, TRUE, &stream);
1087
1088 IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1089
1090 IPersistStreamInit_Load(init, stream);
1091 IPersistStreamInit_Release(init);
1092 IStream_Release(stream);
1093 }
1094
1095 static void do_advise(IHTMLDocument2 *doc, REFIID riid, IUnknown *unk_advise)
1096 {
1097 IConnectionPointContainer *container;
1098 IConnectionPoint *cp;
1099 DWORD cookie;
1100 HRESULT hres;
1101
1102 hres = IHTMLDocument2_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&container);
1103 ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1104
1105 hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1106 IConnectionPointContainer_Release(container);
1107 ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1108
1109 notif_doc = doc;
1110
1111 hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1112 IConnectionPoint_Release(cp);
1113 ok(hres == S_OK, "Advise failed: %08x\n", hres);
1114 }
1115
1116 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1117 {
1118 IOleObject *oleobj;
1119 HRESULT hres;
1120
1121 if(!set && view) {
1122 IOleDocumentView_Show(view, FALSE);
1123 IOleDocumentView_CloseView(view, 0);
1124 IOleDocumentView_SetInPlaceSite(view, NULL);
1125 IOleDocumentView_Release(view);
1126 view = NULL;
1127 }
1128
1129 hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1130 ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1131
1132 hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1133 ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1134
1135 if(set) {
1136 IHlinkTarget *hlink;
1137
1138 hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1139 ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1140
1141 hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1142 ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1143
1144 IHlinkTarget_Release(hlink);
1145 }
1146
1147 IOleObject_Release(oleobj);
1148 }
1149
1150 typedef void (*domtest_t)(IHTMLDocument2*);
1151
1152 static void load_doc(IHTMLDocument2 *doc, const char *str)
1153 {
1154 IHTMLElement *body = NULL;
1155 MSG msg;
1156 HRESULT hres;
1157 static const WCHAR ucPtr[] = {'b','a','c','k','g','r','o','u','n','d',0};
1158 DISPID dispID = -1;
1159 OLECHAR *name;
1160
1161 load_string(doc, str);
1162 do_advise(doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1163
1164 while(!doc_complete && GetMessage(&msg, NULL, 0, 0)) {
1165 TranslateMessage(&msg);
1166 DispatchMessage(&msg);
1167 }
1168
1169 hres = IHTMLDocument2_get_body(doc, &body);
1170 ok(hres == S_OK, "get_body failed: %08x\n", hres);
1171
1172 /* Check we can query for function on the IHTMLElementBody interface */
1173 name = (WCHAR*)ucPtr;
1174 hres = IHTMLElement_GetIDsOfNames(body, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispID);
1175 ok(hres == S_OK, "GetIDsOfNames(background) failed %08x\n", hres);
1176 ok(dispID == DISPID_IHTMLBODYELEMENT_BACKGROUND, "Incorrect dispID got (%d)\n", dispID);
1177
1178 IHTMLElement_Release(body);
1179 }
1180
1181 static IActiveScriptSite *site;
1182 static SCRIPTSTATE state;
1183
1184 static HRESULT WINAPI ObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1185 {
1186 *ppv = NULL;
1187 ok(0, "unexpected call %s\n", debugstr_guid(riid));
1188 return E_NOINTERFACE;
1189 }
1190
1191 static ULONG WINAPI ObjectSafety_AddRef(IObjectSafety *iface)
1192 {
1193 return 2;
1194 }
1195
1196 static ULONG WINAPI ObjectSafety_Release(IObjectSafety *iface)
1197 {
1198 return 1;
1199 }
1200
1201 static HRESULT WINAPI ObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1202 DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1203 {
1204 CHECK_EXPECT(GetInterfaceSafetyOptions);
1205
1206 ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
1207 ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
1208 ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
1209
1210 *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
1211 *pdwEnabledOptions = INTERFACE_USES_DISPEX;
1212
1213 return S_OK;
1214 }
1215
1216 static HRESULT WINAPI ObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1217 DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1218 {
1219 CHECK_EXPECT(SetInterfaceSafetyOptions);
1220
1221 ok(IsEqualGUID(&IID_IActiveScriptParse, riid), "unexpected riid %s\n", debugstr_guid(riid));
1222
1223 ok(dwOptionSetMask == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
1224 "dwOptionSetMask=%x\n", dwOptionSetMask);
1225 ok(dwEnabledOptions == (INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER),
1226 "dwEnabledOptions=%x\n", dwOptionSetMask);
1227
1228 return S_OK;
1229 }
1230
1231 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1232 ObjectSafety_QueryInterface,
1233 ObjectSafety_AddRef,
1234 ObjectSafety_Release,
1235 ObjectSafety_GetInterfaceSafetyOptions,
1236 ObjectSafety_SetInterfaceSafetyOptions
1237 };
1238
1239 static IObjectSafety ObjectSafety = { &ObjectSafetyVtbl };
1240
1241 static HRESULT WINAPI AXObjectSafety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1242 {
1243 *ppv = NULL;
1244
1245 if(IsEqualGUID(&IID_IActiveScript, riid)) {
1246 CHECK_EXPECT(AXQueryInterface_IActiveScript);
1247 return E_NOINTERFACE;
1248 }
1249
1250 if(IsEqualGUID(&IID_IObjectSafety, riid)) {
1251 CHECK_EXPECT(AXQueryInterface_IObjectSafety);
1252 if(!ax_objsafe)
1253 return E_NOINTERFACE;
1254 *ppv = iface;
1255 return S_OK;
1256 }
1257
1258 ok(0, "unexpected call %s\n", debugstr_guid(riid));
1259 return E_NOINTERFACE;
1260 }
1261
1262 static HRESULT WINAPI AXObjectSafety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1263 DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
1264 {
1265 CHECK_EXPECT(AXGetInterfaceSafetyOptions);
1266
1267 ok(IsEqualGUID(&IID_IDispatchEx, riid), "unexpected riid %s\n", debugstr_guid(riid));
1268 ok(pdwSupportedOptions != NULL, "pdwSupportedOptions == NULL\n");
1269 ok(pdwEnabledOptions != NULL, "pdwEnabledOptions == NULL\n");
1270
1271 if(SUCCEEDED(ax_getopt_hres)) {
1272 *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER;
1273 *pdwEnabledOptions = INTERFACE_USES_DISPEX;
1274 }
1275
1276 return ax_getopt_hres;
1277 }
1278
1279 static HRESULT WINAPI AXObjectSafety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1280 DWORD dwOptionSetMask, DWORD dwEnabledOptions)
1281 {
1282 if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1283 CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
1284 ok(dwOptionSetMask == ax_setopt, "dwOptionSetMask=%x, expected %x\n", dwOptionSetMask, ax_setopt);
1285 ok(dwEnabledOptions == ax_setopt, "dwEnabledOptions=%x, expected %x\n", dwOptionSetMask, ax_setopt);
1286 return ax_setopt_dispex_hres;
1287 }
1288
1289 if(IsEqualGUID(&IID_IDispatch, riid)) {
1290 DWORD exopt = ax_setopt & ~INTERFACE_USES_SECURITY_MANAGER;
1291
1292 CHECK_EXPECT(AXSetInterfaceSafetyOptions_IDispatch);
1293 ok(dwOptionSetMask == exopt, "dwOptionSetMask=%x, expected %x\n", dwOptionSetMask, exopt);
1294 ok(dwEnabledOptions == exopt, "dwEnabledOptions=%x, expected %x\n", dwOptionSetMask, exopt);
1295 return ax_setopt_disp_hres;
1296 }
1297
1298 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1299 return E_NOINTERFACE;
1300 }
1301
1302 static const IObjectSafetyVtbl AXObjectSafetyVtbl = {
1303 AXObjectSafety_QueryInterface,
1304 ObjectSafety_AddRef,
1305 ObjectSafety_Release,
1306 AXObjectSafety_GetInterfaceSafetyOptions,
1307 AXObjectSafety_SetInterfaceSafetyOptions
1308 };
1309
1310 static IObjectSafety AXObjectSafety = { &AXObjectSafetyVtbl };
1311
1312 static BOOL set_safe_reg(BOOL init)
1313 {
1314 return init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
1315 NULL, init);
1316 }
1317
1318 static void test_security(void)
1319 {
1320 IInternetHostSecurityManager *sec_mgr;
1321 IServiceProvider *sp;
1322 DWORD policy, policy_size;
1323 struct CONFIRMSAFETY cs;
1324 BYTE *ppolicy;
1325 HRESULT hres;
1326
1327 ax_setopt = INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACE_USES_SECURITY_MANAGER;
1328
1329 hres = IActiveScriptSite_QueryInterface(site, &IID_IServiceProvider, (void**)&sp);
1330 ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1331
1332 hres = IServiceProvider_QueryService(sp, &SID_SInternetHostSecurityManager,
1333 &IID_IInternetHostSecurityManager, (void**)&sec_mgr);
1334 IServiceProvider_Release(sp);
1335 ok(hres == S_OK, "QueryService failed: %08x\n", hres);
1336
1337 hres = IInternetHostSecurityManager_ProcessUrlAction(sec_mgr, URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy),
1338 (BYTE*)&CLSID_TestActiveX, sizeof(CLSID), 0, 0);
1339 ok(hres == S_OK, "ProcessUrlAction failed: %08x\n", hres);
1340 ok(policy == URLPOLICY_ALLOW, "policy = %x\n", policy);
1341
1342 cs.clsid = CLSID_TestActiveX;
1343 cs.pUnk = (IUnknown*)&AXObjectSafety;
1344 cs.dwFlags = 0;
1345
1346 ax_objsafe = TRUE;
1347 SET_EXPECT(AXQueryInterface_IActiveScript);
1348 SET_EXPECT(AXQueryInterface_IObjectSafety);
1349 SET_EXPECT(AXGetInterfaceSafetyOptions);
1350 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
1351 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1352 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1353 CHECK_CALLED(AXQueryInterface_IActiveScript);
1354 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1355 CHECK_CALLED(AXGetInterfaceSafetyOptions);
1356 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx);
1357
1358 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1359 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1360 ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1361 CoTaskMemFree(ppolicy);
1362
1363 ax_objsafe = FALSE;
1364 SET_EXPECT(AXQueryInterface_IActiveScript);
1365 SET_EXPECT(AXQueryInterface_IObjectSafety);
1366 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1367 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1368 CHECK_CALLED(AXQueryInterface_IActiveScript);
1369 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1370
1371 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1372 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1373 ok(*(DWORD*)ppolicy == URLPOLICY_DISALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1374 CoTaskMemFree(ppolicy);
1375
1376 if(set_safe_reg(TRUE)) {
1377 ax_objsafe = FALSE;
1378 SET_EXPECT(AXQueryInterface_IActiveScript);
1379 SET_EXPECT(AXQueryInterface_IObjectSafety);
1380 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1381 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1382 CHECK_CALLED(AXQueryInterface_IActiveScript);
1383 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1384
1385 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1386 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1387 ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1388 CoTaskMemFree(ppolicy);
1389
1390 ax_objsafe = TRUE;
1391 SET_EXPECT(AXQueryInterface_IActiveScript);
1392 SET_EXPECT(AXQueryInterface_IObjectSafety);
1393 SET_EXPECT(AXGetInterfaceSafetyOptions);
1394 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
1395 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1396 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1397 CHECK_CALLED(AXQueryInterface_IActiveScript);
1398 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1399 CHECK_CALLED(AXGetInterfaceSafetyOptions);
1400 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx);
1401
1402 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1403 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1404 ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1405 CoTaskMemFree(ppolicy);
1406
1407 set_safe_reg(FALSE);
1408 }else {
1409 skip("Could not set safety registry\n");
1410 }
1411
1412 ax_objsafe = TRUE;
1413
1414 ax_setopt_dispex_hres = E_NOINTERFACE;
1415 SET_EXPECT(AXQueryInterface_IActiveScript);
1416 SET_EXPECT(AXQueryInterface_IObjectSafety);
1417 SET_EXPECT(AXGetInterfaceSafetyOptions);
1418 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
1419 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch);
1420 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1421 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1422 CHECK_CALLED(AXQueryInterface_IActiveScript);
1423 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1424 CHECK_CALLED(AXGetInterfaceSafetyOptions);
1425 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx);
1426 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch);
1427
1428 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1429 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1430 ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1431 CoTaskMemFree(ppolicy);
1432
1433 ax_setopt_dispex_hres = E_FAIL;
1434 ax_setopt_disp_hres = E_NOINTERFACE;
1435 SET_EXPECT(AXQueryInterface_IActiveScript);
1436 SET_EXPECT(AXQueryInterface_IObjectSafety);
1437 SET_EXPECT(AXGetInterfaceSafetyOptions);
1438 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
1439 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch);
1440 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1441 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1442 CHECK_CALLED(AXQueryInterface_IActiveScript);
1443 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1444 CHECK_CALLED(AXGetInterfaceSafetyOptions);
1445 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx);
1446 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch);
1447
1448 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1449 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1450 ok(*(DWORD*)ppolicy == URLPOLICY_DISALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1451 CoTaskMemFree(ppolicy);
1452
1453 ax_setopt_dispex_hres = E_FAIL;
1454 ax_setopt_disp_hres = S_OK;
1455 ax_getopt_hres = E_NOINTERFACE;
1456 ax_setopt = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
1457 SET_EXPECT(AXQueryInterface_IActiveScript);
1458 SET_EXPECT(AXQueryInterface_IObjectSafety);
1459 SET_EXPECT(AXGetInterfaceSafetyOptions);
1460 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatchEx);
1461 SET_EXPECT(AXSetInterfaceSafetyOptions_IDispatch);
1462 hres = IInternetHostSecurityManager_QueryCustomPolicy(sec_mgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
1463 &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
1464 CHECK_CALLED(AXQueryInterface_IActiveScript);
1465 CHECK_CALLED(AXQueryInterface_IObjectSafety);
1466 CHECK_CALLED(AXGetInterfaceSafetyOptions);
1467 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatchEx);
1468 CHECK_CALLED(AXSetInterfaceSafetyOptions_IDispatch);
1469
1470 ok(hres == S_OK, "QueryCusromPolicy failed: %08x\n", hres);
1471 ok(policy_size == sizeof(DWORD), "policy_size = %d\n", policy_size);
1472 ok(*(DWORD*)ppolicy == URLPOLICY_ALLOW, "policy = %x\n", *(DWORD*)ppolicy);
1473 CoTaskMemFree(ppolicy);
1474
1475 IInternetHostSecurityManager_Release(sec_mgr);
1476 }
1477
1478 static HRESULT WINAPI ActiveScriptProperty_QueryInterface(IActiveScriptProperty *iface, REFIID riid, void **ppv)
1479 {
1480 *ppv = NULL;
1481 ok(0, "unexpected call\n");
1482 return E_NOINTERFACE;
1483 }
1484
1485 static ULONG WINAPI ActiveScriptProperty_AddRef(IActiveScriptProperty *iface)
1486 {
1487 return 2;
1488 }
1489
1490 static ULONG WINAPI ActiveScriptProperty_Release(IActiveScriptProperty *iface)
1491 {
1492 return 1;
1493 }
1494
1495 static HRESULT WINAPI ActiveScriptProperty_GetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
1496 VARIANT *pvarIndex, VARIANT *pvarValue)
1497 {
1498 ok(0, "unexpected call\n");
1499 return E_NOTIMPL;
1500 }
1501
1502 static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty,
1503 VARIANT *pvarIndex, VARIANT *pvarValue)
1504 {
1505 switch(dwProperty) {
1506 case SCRIPTPROP_HACK_TRIDENTEVENTSINK:
1507 CHECK_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
1508 ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1509 ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
1510 break;
1511 case SCRIPTPROP_INVOKEVERSIONING:
1512 CHECK_EXPECT(SetProperty_INVOKEVERSIONING);
1513 ok(V_VT(pvarValue) == VT_I4, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1514 ok(V_I4(pvarValue) == 1, "V_I4(pvarValue)=%d\n", V_I4(pvarValue));
1515 break;
1516 case SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION:
1517 CHECK_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION);
1518 ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue));
1519 ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue));
1520 break;
1521 default:
1522 ok(0, "unexpected property %x\n", dwProperty);
1523 return E_NOTIMPL;
1524 }
1525
1526 ok(!pvarIndex, "pvarIndex != NULL\n");
1527 ok(pvarValue != NULL, "pvarValue == NULL\n");
1528
1529 return S_OK;
1530 }
1531
1532 static const IActiveScriptPropertyVtbl ActiveScriptPropertyVtbl = {
1533 ActiveScriptProperty_QueryInterface,
1534 ActiveScriptProperty_AddRef,
1535 ActiveScriptProperty_Release,
1536 ActiveScriptProperty_GetProperty,
1537 ActiveScriptProperty_SetProperty
1538 };
1539
1540 static IActiveScriptProperty ActiveScriptProperty = { &ActiveScriptPropertyVtbl };
1541
1542 static HRESULT WINAPI ActiveScriptParseProcedure_QueryInterface(IActiveScriptParseProcedure2 *iface, REFIID riid, void **ppv)
1543 {
1544 *ppv = NULL;
1545 ok(0, "unexpected call\n");
1546 return E_NOINTERFACE;
1547 }
1548
1549 static ULONG WINAPI ActiveScriptParseProcedure_AddRef(IActiveScriptParseProcedure2 *iface)
1550 {
1551 return 2;
1552 }
1553
1554 static ULONG WINAPI ActiveScriptParseProcedure_Release(IActiveScriptParseProcedure2 *iface)
1555 {
1556 return 1;
1557 }
1558
1559 static HRESULT WINAPI ActiveScriptParseProcedure_ParseProcedureText(IActiveScriptParseProcedure2 *iface,
1560 LPCOLESTR pstrCode, LPCOLESTR pstrFormalParams, LPCOLESTR pstrProcedureName,
1561 LPCOLESTR pstrItemName, IUnknown *punkContext, LPCOLESTR pstrDelimiter,
1562 CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags, IDispatch **ppdisp)
1563 {
1564 ok(0, "unexpected call\n");
1565 return E_NOTIMPL;
1566 }
1567
1568 static const IActiveScriptParseProcedure2Vtbl ActiveScriptParseProcedureVtbl = {
1569 ActiveScriptParseProcedure_QueryInterface,
1570 ActiveScriptParseProcedure_AddRef,
1571 ActiveScriptParseProcedure_Release,
1572 ActiveScriptParseProcedure_ParseProcedureText
1573 };
1574
1575 static IActiveScriptParseProcedure2 ActiveScriptParseProcedure = { &ActiveScriptParseProcedureVtbl };
1576
1577 static HRESULT WINAPI ActiveScriptParse_QueryInterface(IActiveScriptParse *iface, REFIID riid, void **ppv)
1578 {
1579 *ppv = NULL;
1580 ok(0, "unexpected call\n");
1581 return E_NOINTERFACE;
1582 }
1583
1584 static ULONG WINAPI ActiveScriptParse_AddRef(IActiveScriptParse *iface)
1585 {
1586 return 2;
1587 }
1588
1589 static ULONG WINAPI ActiveScriptParse_Release(IActiveScriptParse *iface)
1590 {
1591 return 1;
1592 }
1593
1594 static HRESULT WINAPI ActiveScriptParse_InitNew(IActiveScriptParse *iface)
1595 {
1596 CHECK_EXPECT(InitNew);
1597 return S_OK;
1598 }
1599
1600 static HRESULT WINAPI ActiveScriptParse_AddScriptlet(IActiveScriptParse *iface,
1601 LPCOLESTR pstrDefaultName, LPCOLESTR pstrCode, LPCOLESTR pstrItemName,
1602 LPCOLESTR pstrSubItemName, LPCOLESTR pstrEventName, LPCOLESTR pstrDelimiter,
1603 CTXARG_T dwSourceContextCookie, ULONG ulStartingLineNumber, DWORD dwFlags,
1604 BSTR *pbstrName, EXCEPINFO *pexcepinfo)
1605 {
1606 ok(0, "unexpected call\n");
1607 return E_NOTIMPL;
1608 }
1609
1610 static HRESULT dispex_propput(IDispatchEx *obj, DISPID id, DWORD flags, VARIANT *var)
1611 {
1612 DISPID propput_arg = DISPID_PROPERTYPUT;
1613 DISPPARAMS dp = {var, &propput_arg, 1, 1};
1614 EXCEPINFO ei = {0};
1615
1616 return IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT|flags, &dp, NULL, &ei, NULL);
1617 }
1618
1619 static void test_func(IDispatchEx *obj)
1620 {
1621 DISPID id;
1622 IDispatchEx *dispex;
1623 IDispatch *disp;
1624 EXCEPINFO ei;
1625 DISPPARAMS dp;
1626 BSTR str;
1627 VARIANT var;
1628 HRESULT hres;
1629
1630 str = a2bstr("toString");
1631 hres = IDispatchEx_GetDispID(obj, str, fdexNameCaseSensitive, &id);
1632 SysFreeString(str);
1633 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1634 ok(id == DISPID_IOMNAVIGATOR_TOSTRING, "id = %x\n", id);
1635
1636 memset(&dp, 0, sizeof(dp));
1637 memset(&ei, 0, sizeof(ei));
1638 VariantInit(&var);
1639 hres = IDispatchEx_InvokeEx(obj, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1640 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1641 ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
1642 ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(var) == NULL\n");
1643 disp = V_DISPATCH(&var);
1644
1645 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1646 IDispatch_Release(disp);
1647 ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
1648
1649 /* FIXME: Test InvokeEx(DISPATCH_METHOD) */
1650
1651 memset(&dp, 0, sizeof(dp));
1652 memset(&ei, 0, sizeof(ei));
1653 VariantInit(&var);
1654 hres = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &var, &ei, NULL);
1655 ok(hres == S_OK || broken(E_ACCESSDENIED), "InvokeEx failed: %08x\n", hres);
1656 if(SUCCEEDED(hres)) {
1657 ok(V_VT(&var) == VT_BSTR, "V_VT(var)=%d\n", V_VT(&var));
1658 ok(!strcmp_wa(V_BSTR(&var), "[object]"), "V_BSTR(var) = %s\n", wine_dbgstr_w(V_BSTR(&var)));
1659 VariantClear(&var);
1660 }
1661
1662 V_VT(&var) = VT_I4;
1663 V_I4(&var) = 100;
1664 hres = dispex_propput(obj, id, 0, &var);
1665 ok(hres == E_NOTIMPL, "InvokeEx failed: %08x\n", hres);
1666
1667 IDispatchEx_Release(dispex);
1668 }
1669
1670 static void test_nextdispid(IDispatchEx *dispex)
1671 {
1672 DISPID last_id = DISPID_STARTENUM, id, dyn_id;
1673 BSTR name;
1674 VARIANT var;
1675 HRESULT hres;
1676
1677 name = a2bstr("dynVal");
1678 hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseSensitive|fdexNameEnsure, &dyn_id);
1679 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1680 SysFreeString(name);
1681
1682 V_VT(&var) = VT_EMPTY;
1683 hres = dispex_propput(dispex, dyn_id, 0, &var);
1684
1685 while(last_id != dyn_id) {
1686 hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, last_id, &id);
1687 ok(hres == S_OK, "GetNextDispID returned: %08x\n", hres);
1688 ok(id != DISPID_STARTENUM, "id == DISPID_STARTENUM\n");
1689 ok(id != DISPID_IOMNAVIGATOR_TOSTRING, "id == DISPID_IOMNAVIGATOR_TOSTRING\n");
1690
1691 hres = IDispatchEx_GetMemberName(dispex, id, &name);
1692 ok(hres == S_OK, "GetMemberName failed: %08x\n", hres);
1693
1694 if(id == dyn_id)
1695 ok(!strcmp_wa(name, "dynVal"), "name = %s\n", wine_dbgstr_w(name));
1696 else if(id == DISPID_IOMNAVIGATOR_PLATFORM)
1697 ok(!strcmp_wa(name, "platform"), "name = %s\n", wine_dbgstr_w(name));
1698
1699 SysFreeString(name);
1700 last_id = id;
1701 }
1702
1703 hres = IDispatchEx_GetNextDispID(dispex, 0, id, &id);
1704 ok(hres == S_FALSE, "GetNextDispID returned: %08x\n", hres);
1705 ok(id == DISPID_STARTENUM, "id != DISPID_STARTENUM\n");
1706 }
1707
1708 static void test_global_id(void)
1709 {
1710 VARIANT var;
1711 DISPPARAMS dp;
1712 EXCEPINFO ei;
1713 BSTR tmp;
1714 DISPID id;
1715 HRESULT hres;
1716
1717 SET_EXPECT(GetScriptDispatch);
1718 SET_EXPECT(script_divid_d);
1719 tmp = a2bstr("divid");
1720 hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1721 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1722 SysFreeString(tmp);
1723 CHECK_CALLED(GetScriptDispatch);
1724 CHECK_CALLED(script_divid_d);
1725
1726 VariantInit(&var);
1727 memset(&ei, 0, sizeof(ei));
1728 memset(&dp, 0, sizeof(dp));
1729 hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1730 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1731 ok(V_VT(&var) == VT_DISPATCH, "V_VT(var) = %d\n", V_VT(&var));
1732 VariantClear(&var);
1733 }
1734
1735 static HRESULT WINAPI ActiveScriptParse_ParseScriptText(IActiveScriptParse *iface,
1736 LPCOLESTR pstrCode, LPCOLESTR pstrItemName, IUnknown *punkContext,
1737 LPCOLESTR pstrDelimiter, CTXARG_T dwSourceContextCookie, ULONG ulStartingLine,
1738 DWORD dwFlags, VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
1739 {
1740 IDispatchEx *document, *dispex;
1741 IHTMLWindow2 *window;
1742 IOmNavigator *navigator;
1743 IUnknown *unk;
1744 VARIANT var, arg;
1745 DISPPARAMS dp;
1746 EXCEPINFO ei;
1747 DISPID id;
1748 BSTR tmp;
1749 HRESULT hres;
1750
1751 static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
1752 static const WCHAR testW[] = {'t','e','s','t',0};
1753 static const WCHAR funcW[] = {'f','u','n','c',0};
1754
1755 CHECK_EXPECT(ParseScriptText);
1756
1757 SET_EXPECT(GetScriptDispatch);
1758
1759 tmp = SysAllocString(documentW);
1760 hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1761 SysFreeString(tmp);
1762 ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
1763 ok(id == DISPID_IHTMLWINDOW2_DOCUMENT, "id=%x\n", id);
1764
1765 CHECK_CALLED(GetScriptDispatch);
1766
1767 VariantInit(&var);
1768 memset(&dp, 0, sizeof(dp));
1769 memset(&ei, 0, sizeof(ei));
1770
1771 hres = IDispatchEx_InvokeEx(window_dispex, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1772 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1773 ok(V_VT(&var) == VT_DISPATCH, "V_VT(var)=%d\n", V_VT(&var));
1774 ok(V_DISPATCH(&var) != NULL, "V_DISPATCH(&var) == NULL\n");
1775
1776 hres = IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IDispatchEx, (void**)&document);
1777 VariantClear(&var);
1778 ok(hres == S_OK, "Could not get DispatchEx: %08x\n", hres);
1779
1780 tmp = SysAllocString(testW);
1781 hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
1782 ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
1783 hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive | fdexNameImplicit, &id);
1784 ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(document) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
1785 SysFreeString(tmp);
1786
1787 id = 0;
1788 tmp = SysAllocString(testW);
1789 hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
1790 SysFreeString(tmp);
1791 ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
1792 ok(id, "id == 0\n");
1793
1794 V_VT(&var) = VT_I4;
1795 V_I4(&var) = 100;
1796 hres = dispex_propput(document, id, 0, &var);
1797 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1798
1799 tmp = SysAllocString(testW);
1800 hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive, &id);
1801 SysFreeString(tmp);
1802 ok(hres == S_OK, "GetDispID(document) failed: %08x\n", hres);
1803
1804 VariantInit(&var);
1805 memset(&dp, 0, sizeof(dp));
1806 memset(&ei, 0, sizeof(ei));
1807 hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1808 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1809 ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1810 ok(V_I4(&var) == 100, "V_I4(&var) = %d\n", V_I4(&var));
1811
1812 V_VT(&var) = VT_I4;
1813 V_I4(&var) = 200;
1814 hres = dispex_propput(document, id, DISPATCH_PROPERTYPUTREF, &var);
1815 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1816
1817 VariantInit(&var);
1818 memset(&dp, 0, sizeof(dp));
1819 memset(&ei, 0, sizeof(ei));
1820 hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1821 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1822 ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1823 ok(V_I4(&var) == 200, "V_I4(&var) = %d\n", V_I4(&var));
1824
1825 memset(&dp, 0, sizeof(dp));
1826 memset(&ei, 0, sizeof(ei));
1827 V_VT(&var) = VT_I4;
1828 V_I4(&var) = 300;
1829 dp.cArgs = 1;
1830 dp.rgvarg = &var;
1831 hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
1832 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1833
1834 VariantInit(&var);
1835 memset(&dp, 0, sizeof(dp));
1836 memset(&ei, 0, sizeof(ei));
1837 hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYGET, &dp, &var, &ei, NULL);
1838 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1839 ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1840 ok(V_I4(&var) == 300, "V_I4(&var) = %d\n", V_I4(&var));
1841
1842 unk = (void*)0xdeadbeef;
1843 hres = IDispatchEx_GetNameSpaceParent(window_dispex, &unk);
1844 ok(hres == S_OK, "GetNameSpaceParent failed: %08x\n", hres);
1845 ok(!unk, "unk=%p, expected NULL\n", unk);
1846
1847 id = 0;
1848 tmp = SysAllocString(funcW);
1849 hres = IDispatchEx_GetDispID(document, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
1850 SysFreeString(tmp);
1851 ok(hres == S_OK, "GetDispID(func) failed: %08x\n", hres);
1852 ok(id, "id == 0\n");
1853
1854 dp.cArgs = 1;
1855 dp.rgvarg = &var;
1856 dp.cNamedArgs = 0;
1857 dp.rgdispidNamedArgs = NULL;
1858 V_VT(&var) = VT_DISPATCH;
1859 V_DISPATCH(&var) = (IDispatch*)&funcDisp;
1860 hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_PROPERTYPUT, &dp, NULL, &ei, NULL);
1861 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1862
1863 VariantInit(&var);
1864 memset(&dp, 0, sizeof(dp));
1865 memset(&ei, 0, sizeof(ei));
1866 V_VT(&arg) = VT_BOOL;
1867 V_BOOL(&arg) = VARIANT_TRUE;
1868 dp.cArgs = 1;
1869 dp.rgvarg = &arg;
1870
1871 SET_EXPECT(funcDisp);
1872 hres = IDispatchEx_InvokeEx(document, id, LOCALE_NEUTRAL, INVOKE_FUNC, &dp, &var, &ei, NULL);
1873 CHECK_CALLED(funcDisp);
1874
1875 ok(hres == S_OK, "InvokeEx(INVOKE_FUNC) failed: %08x\n", hres);
1876 ok(V_VT(&var) == VT_I4, "V_VT(var)=%d\n", V_VT(&var));
1877 ok(V_I4(&var) == 100, "V_I4(&var) == NULL\n");
1878
1879 IDispatchEx_Release(document);
1880
1881 hres = IDispatchEx_QueryInterface(window_dispex, &IID_IHTMLWindow2, (void**)&window);
1882 ok(hres == S_OK, "Could not get IHTMLWindow2 iface: %08x\n", hres);
1883
1884 hres = IHTMLWindow2_get_navigator(window, &navigator);
1885 IHTMLWindow2_Release(window);
1886 ok(hres == S_OK, "get_navigator failed: %08x\n", hres);
1887
1888 hres = IOmNavigator_QueryInterface(navigator, &IID_IDispatchEx, (void**)&dispex);
1889 IOmNavigator_Release(navigator);
1890 ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
1891
1892 test_func(dispex);
1893 test_nextdispid(dispex);
1894
1895 tmp = a2bstr("test");
1896 hres = IDispatchEx_DeleteMemberByName(dispex, tmp, fdexNameCaseSensitive);
1897 ok(hres == E_NOTIMPL, "DeleteMemberByName failed: %08x\n", hres);
1898
1899 IDispatchEx_Release(dispex);
1900
1901 script_disp = (IDispatch*)&scriptDisp;
1902
1903 SET_EXPECT(GetScriptDispatch);
1904 SET_EXPECT(script_testprop_d);
1905 tmp = a2bstr("testProp");
1906 hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1907 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1908 ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
1909 CHECK_CALLED(GetScriptDispatch);
1910 CHECK_CALLED(script_testprop_d);
1911 SysFreeString(tmp);
1912
1913 tmp = a2bstr("testProp");
1914 hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive, &id);
1915 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1916 ok(id != DISPID_SCRIPT_TESTPROP, "id == DISPID_SCRIPT_TESTPROP\n");
1917 SysFreeString(tmp);
1918
1919 SET_EXPECT(GetScriptDispatch);
1920 SET_EXPECT(script_testprop_i);
1921 memset(&ei, 0, sizeof(ei));
1922 memset(&dp, 0, sizeof(dp));
1923 hres = IDispatchEx_InvokeEx(window_dispex, id, 0, DISPATCH_PROPERTYGET, &dp, &var, &ei, NULL);
1924 ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1925 ok(V_VT(&var) == VT_NULL, "V_VT(var) = %d\n", V_VT(&var));
1926 CHECK_CALLED(GetScriptDispatch);
1927 CHECK_CALLED(script_testprop_i);
1928
1929 SET_EXPECT(GetScriptDispatch);
1930 SET_EXPECT(script_testprop2_d);
1931 tmp = a2bstr("testProp2");
1932 hres = IDispatchEx_GetDispID(window_dispex, tmp, fdexNameCaseSensitive|fdexNameEnsure, &id);
1933 ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1934 ok(id != DISPID_SCRIPT_TESTPROP2, "id == DISPID_SCRIPT_TESTPROP2\n");
1935 CHECK_CALLED(GetScriptDispatch);
1936 CHECK_CALLED(script_testprop2_d);
1937 SysFreeString(tmp);
1938
1939 tmp = a2bstr("test");
1940 hres = IDispatchEx_DeleteMemberByName(window_dispex, tmp, fdexNameCaseSensitive);
1941 ok(hres == E_NOTIMPL, "DeleteMemberByName failed: %08x\n", hres);
1942
1943 test_global_id();
1944
1945 test_security();
1946
1947 return S_OK;
1948 }
1949
1950 static const IActiveScriptParseVtbl ActiveScriptParseVtbl = {
1951 ActiveScriptParse_QueryInterface,
1952 ActiveScriptParse_AddRef,
1953 ActiveScriptParse_Release,
1954 ActiveScriptParse_InitNew,
1955 ActiveScriptParse_AddScriptlet,
1956 ActiveScriptParse_ParseScriptText
1957 };
1958
1959 static IActiveScriptParse ActiveScriptParse = { &ActiveScriptParseVtbl };
1960
1961 static HRESULT WINAPI ActiveScript_QueryInterface(IActiveScript *iface, REFIID riid, void **ppv)
1962 {
1963 *ppv = NULL;
1964
1965 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IActiveScript, riid)) {
1966 *ppv = iface;
1967 return S_OK;
1968 }
1969
1970 if(IsEqualGUID(&IID_IActiveScriptParse, riid)) {
1971 *ppv = &ActiveScriptParse;
1972 return S_OK;
1973 }
1974
1975 if(IsEqualGUID(&IID_IActiveScriptParseProcedure2, riid)) {
1976 *ppv = &ActiveScriptParseProcedure;
1977 return S_OK;
1978 }
1979
1980 if(IsEqualGUID(&IID_IActiveScriptProperty, riid)) {
1981 *ppv = &ActiveScriptProperty;
1982 return S_OK;
1983 }
1984
1985 if(IsEqualGUID(&IID_IObjectSafety, riid)) {
1986 *ppv = &ObjectSafety;
1987 return S_OK;
1988 }
1989
1990 if(IsEqualGUID(&IID_IActiveScriptDebug, riid))
1991 return E_NOINTERFACE;
1992
1993 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1994 return E_NOINTERFACE;
1995 }
1996
1997 static ULONG WINAPI ActiveScript_AddRef(IActiveScript *iface)
1998 {
1999 return 2;
2000 }
2001
2002 static ULONG WINAPI ActiveScript_Release(IActiveScript *iface)
2003 {
2004 return 1;
2005 }
2006
2007 static HRESULT WINAPI ActiveScript_SetScriptSite(IActiveScript *iface, IActiveScriptSite *pass)
2008 {
2009 IActiveScriptSiteInterruptPoll *poll;
2010 IActiveScriptSiteDebug *debug;
2011 IServiceProvider *service;
2012 ICanHandleException *canexpection;
2013 LCID lcid;
2014 HRESULT hres;
2015
2016 CHECK_EXPECT(SetScriptSite);
2017
2018 ok(pass != NULL, "pass == NULL\n");
2019
2020 hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteInterruptPoll, (void**)&poll);
2021 ok(hres == S_OK, "Could not get IActiveScriptSiteInterruptPoll interface: %08x\n", hres);
2022 if(FAILED(hres))
2023 IActiveScriptSiteInterruptPoll_Release(poll);
2024
2025 hres = IActiveScriptSite_GetLCID(pass, &lcid);
2026 ok(hres == S_OK, "GetLCID failed: %08x\n", hres);
2027
2028 hres = IActiveScriptSite_OnStateChange(pass, (state = SCRIPTSTATE_INITIALIZED));
2029 ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
2030
2031 hres = IActiveScriptSite_QueryInterface(pass, &IID_IActiveScriptSiteDebug, (void**)&debug);
2032 ok(hres == S_OK, "Could not get IActiveScriptSiteDebug interface: %08x\n", hres);
2033 if(SUCCEEDED(hres))
2034 IActiveScriptSiteDebug32_Release(debug);
2035
2036 hres = IActiveScriptSite_QueryInterface(pass, &IID_ICanHandleException, (void**)&canexpection);
2037 ok(hres == E_NOINTERFACE, "Could not get IID_ICanHandleException interface: %08x\n", hres);
2038
2039 hres = IActiveScriptSite_QueryInterface(pass, &IID_IServiceProvider, (void**)&service);
2040 ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
2041 if(SUCCEEDED(hres))
2042 IServiceProvider_Release(service);
2043
2044 site = pass;
2045 IActiveScriptSite_AddRef(site);
2046 return S_OK;
2047 }
2048
2049 static HRESULT WINAPI ActiveScript_GetScriptSite(IActiveScript *iface, REFIID riid,
2050 void **ppvObject)
2051 {
2052 ok(0, "unexpected call\n");
2053 return E_NOTIMPL;
2054 }
2055
2056 static HRESULT WINAPI ActiveScript_SetScriptState(IActiveScript *iface, SCRIPTSTATE ss)
2057 {
2058 HRESULT hres;
2059
2060 switch(ss) {
2061 case SCRIPTSTATE_STARTED:
2062 CHECK_EXPECT(SetScriptState_STARTED);
2063 break;
2064 case SCRIPTSTATE_CONNECTED:
2065 CHECK_EXPECT(SetScriptState_CONNECTED);
2066 break;
2067 case SCRIPTSTATE_DISCONNECTED:
2068 CHECK_EXPECT(SetScriptState_DISCONNECTED);
2069 break;
2070 default:
2071 ok(0, "unexpected state %d\n", ss);
2072 return E_NOTIMPL;
2073 }
2074
2075 hres = IActiveScriptSite_OnStateChange(site, (state = ss));
2076 ok(hres == S_OK, "OnStateChange failed: %08x\n", hres);
2077
2078 return S_OK;
2079 }
2080
2081 static HRESULT WINAPI ActiveScript_GetScriptState(IActiveScript *iface, SCRIPTSTATE *pssState)
2082 {
2083 CHECK_EXPECT(GetScriptState);
2084
2085 *pssState = state;
2086 return S_OK;
2087 }
2088
2089 static HRESULT WINAPI ActiveScript_Close(IActiveScript *iface)
2090 {
2091 CHECK_EXPECT(Close);
2092 return E_NOTIMPL;
2093 }
2094
2095 static HRESULT WINAPI ActiveScript_AddNamedItem(IActiveScript *iface,
2096 LPCOLESTR pstrName, DWORD dwFlags)
2097 {
2098 IDispatch *disp;
2099 IUnknown *unk = NULL, *unk2;
2100 HRESULT hres;
2101
2102 static const WCHAR windowW[] = {'w','i','n','d','o','w',0};
2103
2104 static const IID unknown_iid = {0x719C3050,0xF9D3,0x11CF,{0xA4,0x93,0x00,0x40,0x05,0x23,0xA8,0xA0}};
2105
2106 CHECK_EXPECT(AddNamedItem);
2107
2108 ok(!lstrcmpW(pstrName, windowW), "pstrName=%s\n", wine_dbgstr_w(pstrName));
2109 ok(dwFlags == (SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS), "dwFlags=%x\n", dwFlags);
2110
2111 hres = IActiveScriptSite_GetItemInfo(site, windowW, SCRIPTINFO_IUNKNOWN, &unk, NULL);
2112 ok(hres == S_OK, "GetItemInfo failed: %08x\n", hres);
2113 ok(unk != NULL, "unk == NULL\n");
2114
2115 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
2116 ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
2117 if(SUCCEEDED(hres))
2118 IDispatch_Release(disp);
2119
2120 hres = IUnknown_QueryInterface(unk, &unknown_iid, (void**)&unk2);
2121 ok(hres == E_NOINTERFACE, "Got ?? interface: %p\n", unk2);
2122 if(SUCCEEDED(hres))
2123 IUnknown_Release(unk2);
2124
2125 hres = IUnknown_QueryInterface(unk, &IID_IDispatchEx, (void**)&window_dispex);
2126 ok(hres == S_OK, "Could not get IDispatchEx interface: %08x\n", hres);
2127
2128 IUnknown_Release(unk);
2129 return S_OK;
2130 }
2131
2132 static HRESULT WINAPI ActiveScript_AddTypeLib(IActiveScript *iface, REFGUID rguidTypeLib,
2133 DWORD dwMajor, DWORD dwMinor, DWORD dwFlags)
2134 {
2135 ok(0, "unexpected call\n");
2136 return E_NOTIMPL;
2137 }
2138
2139 static HRESULT WINAPI ActiveScript_GetScriptDispatch(IActiveScript *iface, LPCOLESTR pstrItemName,
2140 IDispatch **ppdisp)
2141 {
2142 CHECK_EXPECT(GetScriptDispatch);
2143
2144 ok(!strcmp_wa(pstrItemName, "window"), "pstrItemName = %s\n", wine_dbgstr_w(pstrItemName));
2145
2146 if(!script_disp)
2147 return E_NOTIMPL;
2148
2149 *ppdisp = script_disp;
2150 return S_OK;
2151 }
2152
2153 static HRESULT WINAPI ActiveScript_GetCurrentScriptThreadID(IActiveScript *iface,
2154 SCRIPTTHREADID *pstridThread)
2155 {
2156 ok(0, "unexpected call\n");
2157 return E_NOTIMPL;
2158 }
2159
2160 static HRESULT WINAPI ActiveScript_GetScriptThreadID(IActiveScript *iface,
2161 DWORD dwWin32ThreadId, SCRIPTTHREADID *pstidThread)
2162 {
2163 ok(0, "unexpected call\n");
2164 return E_NOTIMPL;
2165 }
2166
2167 static HRESULT WINAPI ActiveScript_GetScriptThreadState(IActiveScript *iface,
2168 SCRIPTTHREADID stidThread, SCRIPTTHREADSTATE *pstsState)
2169 {
2170 ok(0, "unexpected call\n");
2171 return E_NOTIMPL;
2172 }
2173
2174 static HRESULT WINAPI ActiveScript_InterruptScriptThread(IActiveScript *iface,
2175 SCRIPTTHREADID stidThread, const EXCEPINFO *pexcepinfo, DWORD dwFlags)
2176 {
2177 ok(0, "unexpected call\n");
2178 return E_NOTIMPL;
2179 }
2180
2181 static HRESULT WINAPI ActiveScript_Clone(IActiveScript *iface, IActiveScript **ppscript)
2182 {
2183 ok(0, "unexpected call\n");
2184 return E_NOTIMPL;
2185 }
2186
2187 static const IActiveScriptVtbl ActiveScriptVtbl = {
2188 ActiveScript_QueryInterface,
2189 ActiveScript_AddRef,
2190 ActiveScript_Release,
2191 ActiveScript_SetScriptSite,
2192 ActiveScript_GetScriptSite,
2193 ActiveScript_SetScriptState,
2194 ActiveScript_GetScriptState,
2195 ActiveScript_Close,
2196 ActiveScript_AddNamedItem,
2197 ActiveScript_AddTypeLib,
2198 ActiveScript_GetScriptDispatch,
2199 ActiveScript_GetCurrentScriptThreadID,
2200 ActiveScript_GetScriptThreadID,
2201 ActiveScript_GetScriptThreadState,
2202 ActiveScript_InterruptScriptThread,
2203 ActiveScript_Clone
2204 };
2205
2206 static IActiveScript ActiveScript = { &ActiveScriptVtbl };
2207
2208 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2209 {
2210 *ppv = NULL;
2211
2212 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
2213 *ppv = iface;
2214 return S_OK;
2215 }
2216
2217 if(IsEqualGUID(&IID_IMarshal, riid))
2218 return E_NOINTERFACE;
2219 if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
2220 return E_NOINTERFACE;
2221
2222 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
2223 return E_NOTIMPL;
2224 }
2225
2226 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
2227 {
2228 return 2;
2229 }
2230
2231 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
2232 {
2233 return 1;
2234 }
2235
2236 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2237 {
2238 CHECK_EXPECT(CreateInstance);
2239
2240 ok(!outer, "outer = %p\n", outer);
2241 ok(IsEqualGUID(&IID_IActiveScript, riid), "unexpected riid %s\n", debugstr_guid(riid));
2242 *ppv = &ActiveScript;
2243 return S_OK;
2244 }
2245
2246 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
2247 {
2248 ok(0, "unexpected call\n");
2249 return S_OK;
2250 }
2251
2252 static const IClassFactoryVtbl ClassFactoryVtbl = {
2253 ClassFactory_QueryInterface,
2254 ClassFactory_AddRef,
2255 ClassFactory_Release,
2256 ClassFactory_CreateInstance,
2257 ClassFactory_LockServer
2258 };
2259
2260 static IClassFactory script_cf = { &ClassFactoryVtbl };
2261
2262 static const char simple_script_str[] =
2263 "<html><head></head><body>"
2264 "<div id=\"divid\"></div>"
2265 "<script language=\"TestScript\">simple script</script>"
2266 "</body></html>";
2267
2268 static void test_simple_script(void)
2269 {
2270 IHTMLDocument2 *doc;
2271
2272 doc = create_document();
2273 if(!doc)
2274 return;
2275
2276 SET_EXPECT(CreateInstance);
2277 SET_EXPECT(GetInterfaceSafetyOptions);
2278 SET_EXPECT(SetInterfaceSafetyOptions);
2279 SET_EXPECT(SetProperty_INVOKEVERSIONING); /* IE8 */
2280 SET_EXPECT(SetProperty_HACK_TRIDENTEVENTSINK);
2281 SET_EXPECT(InitNew);
2282 SET_EXPECT(SetScriptSite);
2283 SET_EXPECT(GetScriptState);
2284 SET_EXPECT(SetScriptState_STARTED);
2285 SET_EXPECT(AddNamedItem);
2286 SET_EXPECT(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
2287 SET_EXPECT(ParseScriptText);
2288 SET_EXPECT(SetScriptState_CONNECTED);
2289
2290 load_doc(doc, simple_script_str);
2291
2292 CHECK_CALLED(CreateInstance);
2293 CHECK_CALLED(GetInterfaceSafetyOptions);
2294 CHECK_CALLED(SetInterfaceSafetyOptions);
2295 CHECK_CALLED_BROKEN(SetProperty_INVOKEVERSIONING); /* IE8 */
2296 CHECK_CALLED(SetProperty_HACK_TRIDENTEVENTSINK);
2297 CHECK_CALLED(InitNew);
2298 CHECK_CALLED(SetScriptSite);
2299 CHECK_CALLED(GetScriptState);
2300 CHECK_CALLED(SetScriptState_STARTED);
2301 CHECK_CALLED(AddNamedItem);
2302 CHECK_CALLED_BROKEN(SetProperty_ABBREVIATE_GLOBALNAME_RESOLUTION); /* IE8 */
2303 CHECK_CALLED(ParseScriptText);
2304 CHECK_CALLED(SetScriptState_CONNECTED);
2305
2306 if(site)
2307 IActiveScriptSite_Release(site);
2308 if(window_dispex)
2309 IDispatchEx_Release(window_dispex);
2310
2311 SET_EXPECT(SetScriptState_DISCONNECTED);
2312 SET_EXPECT(Close);
2313
2314 IHTMLDocument2_Release(doc);
2315
2316 CHECK_CALLED(SetScriptState_DISCONNECTED);
2317 CHECK_CALLED(Close);
2318 }
2319
2320 static void run_js_script(const char *test_name)
2321 {
2322 WCHAR url[INTERNET_MAX_URL_LENGTH];
2323 char urlA[INTERNET_MAX_URL_LENGTH];
2324 IPersistMoniker *persist;
2325 IHTMLDocument2 *doc;
2326 IMoniker *mon;
2327 MSG msg;
2328 HRESULT hres;
2329
2330 static const char res[] = "res://";
2331
2332 trace("running %s...\n", test_name);
2333
2334 doc = create_document();
2335 if(!doc)
2336 return;
2337
2338 set_client_site(doc, TRUE);
2339 do_advise(doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2340
2341 lstrcpyA(urlA, res);
2342 GetModuleFileNameA(NULL, urlA + lstrlenA(res), sizeof(urlA) - lstrlenA(res));
2343 lstrcatA(urlA, "/");
2344 lstrcatA(urlA, test_name);
2345 MultiByteToWideChar(CP_ACP, 0, urlA, -1, url, sizeof(url)/sizeof(WCHAR));
2346
2347 hres = CreateURLMoniker(NULL, url, &mon);
2348 ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
2349
2350 hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&persist);
2351 ok(hres == S_OK, "Could not get IPersistMoniker iface: %08x\n", hres);
2352
2353 hres = IPersistMoniker_Load(persist, FALSE, mon, NULL, 0);
2354 ok(hres == S_OK, "Load failed: %08x\n", hres);
2355
2356 IMoniker_Release(mon);
2357 IPersistMoniker_Release(persist);
2358
2359 SET_EXPECT(external_success);
2360
2361 while(!called_external_success && GetMessage(&msg, NULL, 0, 0)) {
2362 TranslateMessage(&msg);
2363 DispatchMessage(&msg);
2364 }
2365
2366 CHECK_CALLED(external_success);
2367
2368 set_client_site(doc, FALSE);
2369 IHTMLDocument2_Release(doc);
2370 }
2371
2372 static void run_js_tests(void)
2373 {
2374 run_js_script("jstest.html");
2375 }
2376
2377 static BOOL init_registry(BOOL init)
2378 {
2379 return init_key("TestScript\\CLSID", TESTSCRIPT_CLSID, init)
2380 && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A1-9847-11CF-8F20-00805F2CD064}",
2381 NULL, init)
2382 && init_key("CLSID\\"TESTSCRIPT_CLSID"\\Implemented Categories\\{F0B7A1A2-9847-11CF-8F20-00805F2CD064}",
2383 NULL, init);
2384 }
2385
2386 static BOOL register_script_engine(void)
2387 {
2388 DWORD regid;
2389 HRESULT hres;
2390
2391 if(!init_registry(TRUE)) {
2392 init_registry(FALSE);
2393 return FALSE;
2394 }
2395
2396 hres = CoRegisterClassObject(&CLSID_TestScript, (IUnknown *)&script_cf,
2397 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2398 ok(hres == S_OK, "Could not register screipt engine: %08x\n", hres);
2399
2400 return TRUE;
2401 }
2402
2403 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2404 {
2405 return DefWindowProc(hwnd, msg, wParam, lParam);
2406 }
2407
2408 static HWND create_container_window(void)
2409 {
2410 static const CHAR szHTMLDocumentTest[] = "HTMLDocumentTest";
2411 static WNDCLASSEXA wndclass = {
2412 sizeof(WNDCLASSEXA),
2413 0,
2414 wnd_proc,
2415 0, 0, NULL, NULL, NULL, NULL, NULL,
2416 szHTMLDocumentTest,
2417 NULL
2418 };
2419
2420 RegisterClassExA(&wndclass);
2421 return CreateWindowA(szHTMLDocumentTest, szHTMLDocumentTest,
2422 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2423 300, 300, NULL, NULL, NULL, NULL);
2424 }
2425
2426 START_TEST(script)
2427 {
2428 CoInitialize(NULL);
2429 container_hwnd = create_container_window();
2430
2431 if(winetest_interactive || ! is_ie_hardened()) {
2432 if(register_script_engine()) {
2433 test_simple_script();
2434 run_js_tests();
2435 init_registry(FALSE);
2436 }else {
2437 skip("Could not register TestScript engine\n");
2438 }
2439 }else {
2440 skip("IE running in Enhanced Security Configuration\n");
2441 }
2442
2443 DestroyWindow(container_hwnd);
2444 CoUninitialize();
2445 }
useful hacks and other patches not (yet) suitable for mainline