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