[OLEACC_WINETEST] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / modules / rostests / winetests / oleacc / main.c
1 /*
2 * oleacc tests
3 *
4 * Copyright 2008 Nikolay Sivov
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22
23 #include "wine/test.h"
24 #include <stdio.h>
25
26 #include "initguid.h"
27 #include <oleacc.h>
28
29 #define DEFINE_EXPECT(func) \
30 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
31
32 #define SET_EXPECT(func) \
33 do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
34
35 #define CHECK_EXPECT2(func) \
36 do { \
37 ok(expect_ ##func, "unexpected call " #func "\n"); \
38 called_ ## func = TRUE; \
39 }while(0)
40
41 #define CHECK_EXPECT(func) \
42 do { \
43 CHECK_EXPECT2(func); \
44 expect_ ## func = FALSE; \
45 }while(0)
46
47 #define CHECK_CALLED(func) \
48 do { \
49 ok(called_ ## func, "expected " #func "\n"); \
50 expect_ ## func = called_ ## func = FALSE; \
51 }while(0)
52
53 DEFINE_EXPECT(Accessible_QI_IEnumVARIANT);
54 DEFINE_EXPECT(Accessible_get_accChildCount);
55 DEFINE_EXPECT(Accessible_get_accChild);
56
57 static HANDLE (WINAPI *pGetProcessHandleFromHwnd)(HWND);
58
59 static BOOL init(void)
60 {
61 HMODULE oleacc = GetModuleHandleA("oleacc.dll");
62
63 pGetProcessHandleFromHwnd = (void*)GetProcAddress(oleacc, "GetProcessHandleFromHwnd");
64 if(!pGetProcessHandleFromHwnd) {
65 win_skip("GetProcessHandleFromHwnd not available\n");
66 return FALSE;
67 }
68
69 return TRUE;
70 }
71
72 static HRESULT WINAPI Accessible_QueryInterface(
73 IAccessible *iface, REFIID riid, void **ppvObject)
74 {
75 if(IsEqualIID(riid, &IID_IEnumVARIANT)) {
76 CHECK_EXPECT(Accessible_QI_IEnumVARIANT);
77 return E_NOINTERFACE;
78 }
79
80 ok(0, "unexpected QI call: %s\n", wine_dbgstr_guid(riid));
81 return E_NOTIMPL;
82 }
83
84 static ULONG WINAPI Accessible_AddRef(IAccessible *iface)
85 {
86 return 2;
87 }
88
89 static ULONG WINAPI Accessible_Release(IAccessible *iface)
90 {
91 return 1;
92 }
93
94 static HRESULT WINAPI Accessible_GetTypeInfoCount(
95 IAccessible *iface, UINT *pctinfo)
96 {
97 ok(0, "unexpected call\n");
98 return E_NOTIMPL;
99 }
100
101 static HRESULT WINAPI Accessible_GetTypeInfo(IAccessible *iface,
102 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
103 {
104 ok(0, "unexpected call\n");
105 return E_NOTIMPL;
106 }
107
108 static HRESULT WINAPI Accessible_GetIDsOfNames(IAccessible *iface, REFIID riid,
109 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
110 {
111 ok(0, "unexpected call\n");
112 return E_NOTIMPL;
113 }
114
115 static HRESULT WINAPI Accessible_Invoke(IAccessible *iface, DISPID dispIdMember,
116 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
117 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
118 {
119 ok(0, "unexpected call\n");
120 return E_NOTIMPL;
121 }
122
123 static HRESULT WINAPI Accessible_get_accParent(
124 IAccessible *iface, IDispatch **ppdispParent)
125 {
126 ok(0, "unexpected call\n");
127 return E_NOTIMPL;
128 }
129
130 static HRESULT WINAPI Accessible_get_accChildCount(
131 IAccessible *iface, LONG *pcountChildren)
132 {
133 CHECK_EXPECT(Accessible_get_accChildCount);
134 *pcountChildren = 1;
135 return S_OK;
136 }
137
138 static HRESULT WINAPI Accessible_get_accChild(IAccessible *iface,
139 VARIANT varChildID, IDispatch **ppdispChild)
140 {
141 CHECK_EXPECT(Accessible_get_accChild);
142 ok(V_VT(&varChildID) == VT_I4, "V_VT(&varChildID) = %d\n", V_VT(&varChildID));
143 ok(V_I4(&varChildID) == 1, "V_I4(&varChildID) = %d\n", V_I4(&varChildID));
144
145 *ppdispChild = NULL;
146 return S_OK;
147 }
148
149 static HRESULT WINAPI Accessible_get_accName(IAccessible *iface,
150 VARIANT varID, BSTR *pszName)
151 {
152 ok(0, "unexpected call\n");
153 return E_NOTIMPL;
154 }
155
156 static HRESULT WINAPI Accessible_get_accValue(IAccessible *iface,
157 VARIANT varID, BSTR *pszValue)
158 {
159 ok(0, "unexpected call\n");
160 return E_NOTIMPL;
161 }
162
163 static HRESULT WINAPI Accessible_get_accDescription(IAccessible *iface,
164 VARIANT varID, BSTR *pszDescription)
165 {
166 ok(0, "unexpected call\n");
167 return E_NOTIMPL;
168 }
169
170 static HRESULT WINAPI Accessible_get_accRole(IAccessible *iface,
171 VARIANT varID, VARIANT *pvarRole)
172 {
173 ok(0, "unexpected call\n");
174 return E_NOTIMPL;
175 }
176
177 static HRESULT WINAPI Accessible_get_accState(IAccessible *iface,
178 VARIANT varID, VARIANT *pvarState)
179 {
180 ok(0, "unexpected call\n");
181 return E_NOTIMPL;
182 }
183
184 static HRESULT WINAPI Accessible_get_accHelp(IAccessible *iface,
185 VARIANT varID, BSTR *pszHelp)
186 {
187 ok(0, "unexpected call\n");
188 return E_NOTIMPL;
189 }
190
191 static HRESULT WINAPI Accessible_get_accHelpTopic(IAccessible *iface,
192 BSTR *pszHelpFile, VARIANT varID, LONG *pidTopic)
193 {
194 ok(0, "unexpected call\n");
195 return E_NOTIMPL;
196 }
197
198 static HRESULT WINAPI Accessible_get_accKeyboardShortcut(IAccessible *iface,
199 VARIANT varID, BSTR *pszKeyboardShortcut)
200 {
201 ok(0, "unexpected call\n");
202 return E_NOTIMPL;
203 }
204
205 static HRESULT WINAPI Accessible_get_accFocus(IAccessible *iface, VARIANT *pvarID)
206 {
207 ok(0, "unexpected call\n");
208 return E_NOTIMPL;
209 }
210
211 static HRESULT WINAPI Accessible_get_accSelection(
212 IAccessible *iface, VARIANT *pvarID)
213 {
214 ok(0, "unexpected call\n");
215 return E_NOTIMPL;
216 }
217
218 static HRESULT WINAPI Accessible_get_accDefaultAction(IAccessible *iface,
219 VARIANT varID, BSTR *pszDefaultAction)
220 {
221 ok(0, "unexpected call\n");
222 return E_NOTIMPL;
223 }
224
225 static HRESULT WINAPI Accessible_accSelect(IAccessible *iface,
226 LONG flagsSelect, VARIANT varID)
227 {
228 ok(0, "unexpected call\n");
229 return E_NOTIMPL;
230 }
231
232 static HRESULT WINAPI Accessible_accLocation(IAccessible *iface, LONG *pxLeft,
233 LONG *pyTop, LONG *pcxWidth, LONG *pcyHeight, VARIANT varID)
234 {
235 ok(0, "unexpected call\n");
236 return E_NOTIMPL;
237 }
238
239 static HRESULT WINAPI Accessible_accNavigate(IAccessible *iface,
240 LONG navDir, VARIANT varStart, VARIANT *pvarEnd)
241 {
242 ok(0, "unexpected call\n");
243 return E_NOTIMPL;
244 }
245
246 static HRESULT WINAPI Accessible_accHitTest(IAccessible *iface,
247 LONG xLeft, LONG yTop, VARIANT *pvarID)
248 {
249 ok(0, "unexpected call\n");
250 return E_NOTIMPL;
251 }
252
253 static HRESULT WINAPI Accessible_accDoDefaultAction(
254 IAccessible *iface, VARIANT varID)
255 {
256 ok(0, "unexpected call\n");
257 return E_NOTIMPL;
258 }
259
260 static HRESULT WINAPI Accessible_put_accName(IAccessible *iface,
261 VARIANT varID, BSTR pszName)
262 {
263 ok(0, "unexpected call\n");
264 return E_NOTIMPL;
265 }
266
267 static HRESULT WINAPI Accessible_put_accValue(IAccessible *iface,
268 VARIANT varID, BSTR pszValue)
269 {
270 ok(0, "unexpected call\n");
271 return E_NOTIMPL;
272 }
273
274 static IAccessibleVtbl AccessibleVtbl = {
275 Accessible_QueryInterface,
276 Accessible_AddRef,
277 Accessible_Release,
278 Accessible_GetTypeInfoCount,
279 Accessible_GetTypeInfo,
280 Accessible_GetIDsOfNames,
281 Accessible_Invoke,
282 Accessible_get_accParent,
283 Accessible_get_accChildCount,
284 Accessible_get_accChild,
285 Accessible_get_accName,
286 Accessible_get_accValue,
287 Accessible_get_accDescription,
288 Accessible_get_accRole,
289 Accessible_get_accState,
290 Accessible_get_accHelp,
291 Accessible_get_accHelpTopic,
292 Accessible_get_accKeyboardShortcut,
293 Accessible_get_accFocus,
294 Accessible_get_accSelection,
295 Accessible_get_accDefaultAction,
296 Accessible_accSelect,
297 Accessible_accLocation,
298 Accessible_accNavigate,
299 Accessible_accHitTest,
300 Accessible_accDoDefaultAction,
301 Accessible_put_accName,
302 Accessible_put_accValue
303 };
304
305 static IAccessible Accessible = {&AccessibleVtbl};
306
307 static void test_getroletext(void)
308 {
309 INT ret, role;
310 CHAR buf[2], *buff;
311 WCHAR bufW[2], *buffW;
312
313 /* wrong role number */
314 ret = GetRoleTextA(-1, NULL, 0);
315 ok(ret == 0, "GetRoleTextA doesn't return zero on wrong role number, got %d\n", ret);
316 buf[0] = '*';
317 ret = GetRoleTextA(-1, buf, 2);
318 ok(ret == 0, "GetRoleTextA doesn't return zero on wrong role number, got %d\n", ret);
319 ok(buf[0] == 0, "GetRoleTextA doesn't return NULL char on wrong role number\n");
320 buf[0] = '*';
321 ret = GetRoleTextA(-1, buf, 0);
322 ok(ret == 0, "GetRoleTextA doesn't return zero on wrong role number, got %d\n", ret);
323 ok(buf[0] == '*', "GetRoleTextA modified buffer on wrong role number\n");
324
325 ret = GetRoleTextW(-1, NULL, 0);
326 ok(ret == 0, "GetRoleTextW doesn't return zero on wrong role number, got %d\n", ret);
327 bufW[0] = '*';
328 ret = GetRoleTextW(-1, bufW, 2);
329 ok(ret == 0, "GetRoleTextW doesn't return zero on wrong role number, got %d\n", ret);
330 ok(bufW[0] == '\0', "GetRoleTextW doesn't return NULL char on wrong role number\n");
331 bufW[0] = '*';
332 ret = GetRoleTextW(-1, bufW, 0);
333 ok(ret == 0, "GetRoleTextW doesn't return zero on wrong role number, got %d\n", ret);
334
335 /* zero role number - not documented */
336 ret = GetRoleTextA(0, NULL, 0);
337 ok(ret > 0, "GetRoleTextA doesn't return (>0) for zero role number, got %d\n", ret);
338 ret = GetRoleTextW(0, NULL, 0);
339 ok(ret > 0, "GetRoleTextW doesn't return (>0) for zero role number, got %d\n", ret);
340
341 /* NULL buffer, return length */
342 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, NULL, 0);
343 ok(ret > 0, "GetRoleTextA doesn't return length on NULL buffer, got %d\n", ret);
344 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, NULL, 1);
345 ok(ret > 0, "GetRoleTextA doesn't return length on NULL buffer, got %d\n", ret);
346 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, NULL, 0);
347 ok(ret > 0, "GetRoleTextW doesn't return length on NULL buffer, got %d\n", ret);
348 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, NULL, 1);
349 ok(ret > 0, "GetRoleTextW doesn't return length on NULL buffer, got %d\n", ret);
350
351 /* use a smaller buffer */
352 bufW[0] = '*';
353 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buf, 0);
354 ok(!ret, "GetRoleTextA doesn't return 0, got %d\n", ret);
355 ok(buf[0] == '*', "GetRoleTextA modified buffer\n");
356 buffW = NULL;
357 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, (WCHAR*)&buffW, 0);
358 ok(ret, "GetRoleTextW doesn't return length\n");
359 ok(buffW != NULL, "GetRoleTextW doesn't modify buffer\n");
360 buf[0] = '*';
361 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buf, 1);
362 ok(ret == 0, "GetRoleTextA returned wrong length\n");
363 ok(buf[0] == '\0', "GetRoleTextA returned not zero-length buffer\n");
364 buf[0] = '*';
365 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buf, 2);
366 ok(!ret, "GetRoleTextA returned wrong length, got %d, expected 0\n", ret);
367 ok(!buf[0] || broken(buf[0]!='*') /* WinXP */,
368 "GetRoleTextA returned not zero-length buffer : (%c)\n", buf[0]);
369
370 bufW[0] = '*';
371 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, bufW, 1);
372 ok(ret == 0, "GetRoleTextW returned wrong length, got %d, expected 1\n", ret);
373 ok(bufW[0] == '\0', "GetRoleTextW returned not zero-length buffer\n");
374 bufW[1] = '*';
375 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, bufW, 2);
376 ok(ret == 1, "GetRoleTextW returned wrong length, got %d, expected 1\n", ret);
377 ok(bufW[1] == '\0', "GetRoleTextW returned not zero-length buffer\n");
378
379 /* use bigger buffer */
380 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, NULL, 0);
381 buff = HeapAlloc(GetProcessHeap(), 0, 2*ret);
382 buff[2*ret-1] = '*';
383 ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buff, 2*ret);
384 ok(buff[2*ret-1] == '*', "GetRoleTextA shouldn't modify this part of buffer\n");
385 HeapFree(GetProcessHeap(), 0, buff);
386
387 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, NULL, 0);
388 buffW = HeapAlloc(GetProcessHeap(), 0, 2*ret*sizeof(WCHAR));
389 buffW[2*ret-1] = '*';
390 ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, buffW, 2*ret);
391 ok(buffW[2*ret-1] == '*', "GetRoleTextW shouldn't modify this part of buffer\n");
392 HeapFree(GetProcessHeap(), 0, buffW);
393
394 /* check returned length for all roles */
395 for(role = 0; role <= ROLE_SYSTEM_OUTLINEBUTTON; role++){
396 CHAR buff2[100];
397 WCHAR buff2W[100];
398
399 /* NT4 and W2K don't clear the buffer on a nonexistent role in the A-call */
400 memset(buff2, 0, sizeof(buff2));
401
402 ret = GetRoleTextA(role, NULL, 0);
403 ok(ret > 0, "Expected the role to be present\n");
404
405 GetRoleTextA(role, buff2, sizeof(buff2));
406 ok(ret == lstrlenA(buff2),
407 "GetRoleTextA: returned length doesn't match returned buffer for role %d\n", role);
408
409 /* Win98 and WinMe don't clear the buffer on a nonexistent role in the W-call */
410 memset(buff2W, 0, sizeof(buff2W));
411
412 ret = GetRoleTextW(role, NULL, 0);
413 GetRoleTextW(role, buff2W, ARRAY_SIZE(buff2W));
414 ok(ret == lstrlenW(buff2W),
415 "GetRoleTextW: returned length doesn't match returned buffer for role %d\n", role);
416 }
417 }
418
419 static void test_GetStateText(void)
420 {
421 WCHAR buf[1024], buf2[1024];
422 char bufa[1024];
423 void *ptr;
424 UINT ret, ret2;
425 int i;
426
427 ret2 = GetStateTextW(0, NULL, 1024);
428 ok(ret2, "GetStateText failed\n");
429
430 ptr = NULL;
431 ret = GetStateTextW(0, (WCHAR*)&ptr, 0);
432 ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
433 ok(ptr != NULL, "ptr was not changed\n");
434
435 ret = GetStateTextW(0, buf, 1024);
436 ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
437 ok(!memcmp(buf, ptr, ret*sizeof(WCHAR)), "got %s, expected %s\n",
438 wine_dbgstr_wn(buf, ret), wine_dbgstr_wn(ptr, ret));
439
440 ret = GetStateTextW(0, buf, 1);
441 ok(!ret, "got %d, expected 0\n", ret);
442 ok(!buf[0], "buf[0] = '%c'\n", buf[0]);
443
444 for(i=0; i<31; i++) {
445 ret = GetStateTextW(1<<i, buf, 1024);
446 ok(ret, "%d) GetStateText failed\n", i);
447 }
448 ret = GetStateTextW(1u<<31, buf, 1024);
449 ok(!ret, "31) GetStateText succeeded: %d\n", ret);
450
451 ret = GetStateTextW(2, buf, 1024);
452 ok(ret, "GetStateText failed\n");
453 ret2 = GetStateTextW(3, buf2, 1024);
454 ok(ret2, "GetStateText failed\n");
455 ok(ret == ret2, "got %d, expected %d\n", ret2, ret);
456 ok(!memcmp(buf, buf2, ret*sizeof(WCHAR)),
457 "GetStateText(2,...) returned different data than GetStateText(3,...)\n");
458
459 ret2 = GetStateTextA(0, NULL, 1024);
460 ok(ret2, "GetStateText failed\n");
461
462 ptr = NULL;
463 ret = GetStateTextA(0, (CHAR*)&ptr, 0);
464 ok(!ret, "got %d\n", ret);
465 ok(ptr == NULL, "ptr was changed\n");
466
467 ret = GetStateTextA(0, NULL, 0);
468 ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
469
470 ret = GetStateTextA(0, bufa, 1024);
471 ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
472
473 ret = GetStateTextA(0, bufa, 1);
474 ok(!ret, "got %d, expected 0\n", ret);
475 ok(!bufa[0], "bufa[0] = '%c'\n", bufa[0]);
476
477 for(i=0; i<31; i++) {
478 ret = GetStateTextA(1<<i, bufa, 1024);
479 ok(ret, "%d) GetStateText failed\n", i);
480 }
481 ret = GetStateTextA(1u<<31, bufa, 1024);
482 ok(!ret, "31) GetStateText succeeded: %d\n", ret);
483 }
484
485 static int Object_ref = 1;
486 static HRESULT WINAPI Object_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
487 {
488 if(IsEqualIID(riid, &IID_IUnknown)) {
489 *ppv = iface;
490 IUnknown_AddRef(iface);
491 return S_OK;
492 }
493 return E_NOINTERFACE;
494 }
495
496 static ULONG WINAPI Object_AddRef(IUnknown *iface)
497 {
498 return InterlockedIncrement(&Object_ref);
499 }
500
501 static ULONG WINAPI Object_Release(IUnknown *iface)
502 {
503 return InterlockedDecrement(&Object_ref);
504 }
505
506 static IUnknownVtbl ObjectVtbl = {
507 Object_QueryInterface,
508 Object_AddRef,
509 Object_Release
510 };
511
512 static IUnknown Object = {&ObjectVtbl};
513
514 static void test_LresultFromObject(const char *name)
515 {
516 PROCESS_INFORMATION proc;
517 STARTUPINFOA startup;
518 char cmdline[MAX_PATH];
519 IUnknown *unk;
520 HRESULT hres;
521 LRESULT lres;
522
523 lres = LresultFromObject(NULL, 0, 0);
524 ok(lres == E_INVALIDARG, "got %lx\n", lres);
525
526 hres = ObjectFromLresult(0, &IID_IUnknown, 0, (void**)&unk);
527 ok(hres == E_FAIL, "got %x\n", hres);
528 hres = ObjectFromLresult(0x10000, &IID_IUnknown, 0, (void**)&unk);
529 ok(hres == E_FAIL, "got %x\n", hres);
530
531 ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
532 lres = LresultFromObject(&IID_IUnknown, 0, &Object);
533 ok(SUCCEEDED(lres), "got %lx\n", lres);
534 ok(Object_ref > 1, "Object_ref = %d\n", Object_ref);
535
536 hres = ObjectFromLresult(lres, &IID_IUnknown, 0, (void**)&unk);
537 ok(hres == S_OK, "hres = %x\n", hres);
538 ok(unk == &Object, "unk != &Object\n");
539 IUnknown_Release(unk);
540 ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
541
542 lres = LresultFromObject(&IID_IUnknown, 0, &Object);
543 ok(SUCCEEDED(lres), "got %lx\n", lres);
544 ok(Object_ref > 1, "Object_ref = %d\n", Object_ref);
545
546 sprintf(cmdline, "\"%s\" main ObjectFromLresult %s", name, wine_dbgstr_longlong(lres));
547 memset(&startup, 0, sizeof(startup));
548 startup.cb = sizeof(startup);
549 CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &proc);
550 winetest_wait_child_process(proc.hProcess);
551 ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
552 }
553
554 static LRESULT WINAPI test_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
555 {
556 switch(msg) {
557 case WM_GETOBJECT:
558 if(lparam == OBJID_QUERYCLASSNAMEIDX) {
559 ok(!wparam, "wparam = %lx\n", wparam);
560 return 0;
561 }
562
563 ok(wparam==0xffffffff, "wparam = %lx\n", wparam);
564 if(lparam == (DWORD)OBJID_CURSOR)
565 return E_UNEXPECTED;
566 if(lparam == (DWORD)OBJID_CLIENT)
567 return LresultFromObject(&IID_IUnknown, wparam, &Object);
568 if(lparam == (DWORD)OBJID_WINDOW)
569 return 0;
570
571 ok(0, "unexpected (%ld)\n", lparam);
572 return 0;
573 }
574
575 return DefWindowProcA(hwnd, msg, wparam, lparam);
576 }
577
578 static BOOL register_window_class(void)
579 {
580 WNDCLASSA cls;
581
582 memset(&cls, 0, sizeof(cls));
583 cls.lpfnWndProc = test_window_proc;
584 cls.lpszClassName = "oleacc_test";
585 cls.hInstance = GetModuleHandleA(NULL);
586
587 return RegisterClassA(&cls);
588 }
589
590 static void unregister_window_class(void)
591 {
592 UnregisterClassA("oleacc_test", NULL);
593 }
594
595 static void test_AccessibleObjectFromWindow(void)
596 {
597 IUnknown *unk;
598 HRESULT hr;
599 HWND hwnd;
600
601 hr = AccessibleObjectFromWindow(NULL, OBJID_CURSOR, &IID_IUnknown, NULL);
602 ok(hr == E_INVALIDARG, "got %x\n", hr);
603
604 hr = AccessibleObjectFromWindow(NULL, OBJID_CURSOR, &IID_IUnknown, (void**)&unk);
605 todo_wine ok(hr == S_OK, "got %x\n", hr);
606 if(hr == S_OK) IUnknown_Release(unk);
607
608 hwnd = CreateWindowA("oleacc_test", "test", WS_OVERLAPPEDWINDOW,
609 0, 0, 0, 0, NULL, NULL, NULL, NULL);
610 ok(hwnd != NULL, "CreateWindow failed\n");
611
612 hr = AccessibleObjectFromWindow(hwnd, OBJID_CURSOR, &IID_IUnknown, (void**)&unk);
613 ok(hr == E_UNEXPECTED, "got %x\n", hr);
614
615 ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
616 hr = AccessibleObjectFromWindow(hwnd, OBJID_CLIENT, &IID_IUnknown, (void**)&unk);
617 ok(hr == S_OK, "got %x\n", hr);
618 ok(Object_ref == 2, "Object_ref = %d\n", Object_ref);
619 IUnknown_Release(unk);
620
621 DestroyWindow(hwnd);
622 }
623
624 static void test_GetProcessHandleFromHwnd(void)
625 {
626 HANDLE proc;
627 HWND hwnd;
628
629 proc = pGetProcessHandleFromHwnd(NULL);
630 ok(!proc, "proc = %p\n", proc);
631
632 hwnd = CreateWindowA("static", "", 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
633 ok(hwnd != NULL, "CreateWindow failed\n");
634
635 proc = pGetProcessHandleFromHwnd(hwnd);
636 ok(proc != NULL, "proc == NULL\n");
637 CloseHandle(proc);
638
639 DestroyWindow(hwnd);
640 }
641
642 static void test_AccessibleChildren(IAccessible *acc)
643 {
644 VARIANT children[3];
645 LONG count;
646 HRESULT hr;
647
648 count = -1;
649 hr = AccessibleChildren(NULL, 0, 0, children, &count);
650 ok(hr == E_INVALIDARG, "AccessibleChildren returned %x\n", hr);
651 ok(count == -1, "count = %d\n", count);
652 hr = AccessibleChildren(acc, 0, 0, NULL, &count);
653 ok(hr == E_INVALIDARG, "AccessibleChildren returned %x\n", hr);
654 ok(count == -1, "count = %d\n", count);
655 hr = AccessibleChildren(acc, 0, 0, children, NULL);
656 ok(hr == E_INVALIDARG, "AccessibleChildren returned %x\n", hr);
657
658 if(acc == &Accessible) {
659 SET_EXPECT(Accessible_QI_IEnumVARIANT);
660 SET_EXPECT(Accessible_get_accChildCount);
661 }
662 hr = AccessibleChildren(acc, 0, 0, children, &count);
663 ok(hr == S_OK, "AccessibleChildren returned %x\n", hr);
664 if(acc == &Accessible) {
665 CHECK_CALLED(Accessible_QI_IEnumVARIANT);
666 CHECK_CALLED(Accessible_get_accChildCount);
667 }
668 ok(!count, "count = %d\n", count);
669 count = -1;
670 if(acc == &Accessible) {
671 SET_EXPECT(Accessible_QI_IEnumVARIANT);
672 SET_EXPECT(Accessible_get_accChildCount);
673 }
674 hr = AccessibleChildren(acc, 5, 0, children, &count);
675 ok(hr == S_OK, "AccessibleChildren returned %x\n", hr);
676 if(acc == &Accessible) {
677 CHECK_CALLED(Accessible_QI_IEnumVARIANT);
678 CHECK_CALLED(Accessible_get_accChildCount);
679 }
680 ok(!count, "count = %d\n", count);
681
682 memset(children, 0xfe, sizeof(children));
683 V_VT(children) = VT_DISPATCH;
684 if(acc == &Accessible) {
685 SET_EXPECT(Accessible_QI_IEnumVARIANT);
686 SET_EXPECT(Accessible_get_accChildCount);
687 SET_EXPECT(Accessible_get_accChild);
688 }
689 hr = AccessibleChildren(acc, 0, 1, children, &count);
690 ok(hr == S_OK, "AccessibleChildren returned %x\n", hr);
691 if(acc == &Accessible) {
692 CHECK_CALLED(Accessible_QI_IEnumVARIANT);
693 CHECK_CALLED(Accessible_get_accChildCount);
694 CHECK_CALLED(Accessible_get_accChild);
695
696 ok(V_VT(children) == VT_I4, "V_VT(children) = %d\n", V_VT(children));
697 ok(V_I4(children) == 1, "V_I4(children) = %d\n", V_I4(children));
698 }else {
699 ok(V_VT(children) == VT_DISPATCH, "V_VT(children) = %d\n", V_VT(children));
700 IDispatch_Release(V_DISPATCH(children));
701 }
702 ok(count == 1, "count = %d\n", count);
703
704 if(acc == &Accessible) {
705 SET_EXPECT(Accessible_QI_IEnumVARIANT);
706 SET_EXPECT(Accessible_get_accChildCount);
707 SET_EXPECT(Accessible_get_accChild);
708 }
709 hr = AccessibleChildren(acc, 0, 3, children, &count);
710 ok(hr == S_FALSE, "AccessibleChildren returned %x\n", hr);
711 if(acc == &Accessible) {
712 CHECK_CALLED(Accessible_QI_IEnumVARIANT);
713 CHECK_CALLED(Accessible_get_accChildCount);
714 CHECK_CALLED(Accessible_get_accChild);
715
716 ok(V_VT(children) == VT_I4, "V_VT(children) = %d\n", V_VT(children));
717 ok(V_I4(children) == 1, "V_I4(children) = %d\n", V_I4(children));
718 }else {
719 ok(V_VT(children) == VT_DISPATCH, "V_VT(children) = %d\n", V_VT(children));
720 IDispatch_Release(V_DISPATCH(children));
721 }
722 ok(count == 1, "count = %d\n", count);
723 ok(V_VT(children+1) == VT_EMPTY, "V_VT(children+1) = %d\n", V_VT(children+1));
724 ok(V_VT(children+2) == VT_EMPTY, "V_VT(children+2) = %d\n", V_VT(children+2));
725 }
726
727 static void test_default_client_accessible_object(void)
728 {
729 static const WCHAR testW[] = {'t','e','s','t',' ','t',' ','&','j','u','n','k',0};
730 static const WCHAR shortcutW[] = {'A','l','t','+','t',0};
731
732 IAccessible *acc;
733 IDispatch *disp;
734 IOleWindow *ow;
735 IEnumVARIANT *ev;
736 HWND chld, hwnd, hwnd2;
737 HRESULT hr;
738 VARIANT vid, v;
739 BSTR str;
740 POINT pt;
741 RECT rect;
742 LONG l, left, top, width, height;
743 ULONG fetched;
744
745 hwnd = CreateWindowA("oleacc_test", "test &t &junk", WS_OVERLAPPEDWINDOW,
746 0, 0, 100, 100, NULL, NULL, NULL, NULL);
747 ok(hwnd != NULL, "CreateWindow failed\n");
748 chld = CreateWindowA("static", "message", WS_CHILD | WS_VISIBLE,
749 0, 0, 50, 50, hwnd, NULL, NULL, NULL);
750 ok(chld != NULL, "CreateWindow failed\n");
751
752 hr = CreateStdAccessibleObject(NULL, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
753 ok(hr == E_FAIL, "got %x\n", hr);
754
755 hr = CreateStdAccessibleObject(hwnd, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
756 ok(hr == S_OK, "got %x\n", hr);
757
758 hr = IAccessible_QueryInterface(acc, &IID_IOleWindow, (void**)&ow);
759 ok(hr == S_OK, "got %x\n", hr);
760 hr = IOleWindow_GetWindow(ow, &hwnd2);
761 ok(hr == S_OK, "got %x\n", hr);
762 ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
763 hr = WindowFromAccessibleObject(acc, &hwnd2);
764 ok(hr == S_OK, "got %x\n", hr);
765 ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
766 IOleWindow_Release(ow);
767
768 hr = IAccessible_get_accChildCount(acc, &l);
769 ok(hr == S_OK, "got %x\n", hr);
770 ok(l == 1, "l = %d\n", l);
771
772 V_VT(&vid) = VT_I4;
773 V_I4(&vid) = CHILDID_SELF;
774 disp = (void*)0xdeadbeef;
775 hr = IAccessible_get_accChild(acc, vid, &disp);
776 ok(hr == E_INVALIDARG, "get_accChild returned %x\n", hr);
777 ok(disp == NULL, "disp = %p\n", disp);
778
779 V_I4(&vid) = 1;
780 disp = (void*)0xdeadbeef;
781 hr = IAccessible_get_accChild(acc, vid, &disp);
782 ok(hr == E_INVALIDARG, "get_accChild returned %x\n", hr);
783 ok(disp == NULL, "disp = %p\n", disp);
784
785 hr = IAccessible_QueryInterface(acc, &IID_IEnumVARIANT, (void**)&ev);
786 ok(hr == S_OK, "got %x\n", hr);
787
788 hr = IEnumVARIANT_Skip(ev, 100);
789 ok(hr == S_FALSE, "Skip returned %x\n", hr);
790
791 V_VT(&v) = VT_I4;
792 fetched = 1;
793 hr = IEnumVARIANT_Next(ev, 1, &v, &fetched);
794 ok(hr == S_FALSE, "got %x\n", hr);
795 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
796 ok(fetched == 0, "fetched = %d\n", fetched);
797
798 hr = IEnumVARIANT_Reset(ev);
799 ok(hr == S_OK, "got %x\n", hr);
800
801 V_VT(&v) = VT_I4;
802 fetched = 2;
803 hr = IEnumVARIANT_Next(ev, 1, &v, &fetched);
804 ok(hr == S_OK, "got %x\n", hr);
805 ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
806 IDispatch_Release(V_DISPATCH(&v));
807 ok(fetched == 1, "fetched = %d\n", fetched);
808 IEnumVARIANT_Release(ev);
809
810 test_AccessibleChildren(acc);
811
812 V_VT(&vid) = VT_I4;
813 V_I4(&vid) = CHILDID_SELF;
814 hr = IAccessible_get_accName(acc, vid, &str);
815 ok(hr == S_OK, "got %x\n", hr);
816 ok(!lstrcmpW(str, testW), "name = %s\n", wine_dbgstr_w(str));
817 SysFreeString(str);
818
819 V_I4(&vid) = 1;
820 str = (void*)0xdeadbeef;
821 hr = IAccessible_get_accName(acc, vid, &str);
822 ok(hr == E_INVALIDARG, "got %x\n", hr);
823 ok(!str, "str != NULL\n");
824 V_I4(&vid) = CHILDID_SELF;
825
826 str = (void*)0xdeadbeef;
827 hr = IAccessible_get_accValue(acc, vid, &str);
828 ok(hr == S_FALSE, "got %x\n", hr);
829 ok(!str, "str != NULL\n");
830
831 str = (void*)0xdeadbeef;
832 hr = IAccessible_get_accDescription(acc, vid, &str);
833 ok(hr == S_FALSE, "got %x\n", hr);
834 ok(!str, "str != NULL\n");
835
836 V_VT(&v) = VT_DISPATCH;
837 V_DISPATCH(&v) = (void*)0xdeadbeef;
838 hr = IAccessible_get_accRole(acc, vid, &v);
839 ok(hr == S_OK, "got %x\n", hr);
840 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
841 ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
842
843 V_VT(&v) = VT_DISPATCH;
844 V_DISPATCH(&v) = (void*)0xdeadbeef;
845 hr = IAccessible_get_accState(acc, vid, &v);
846 ok(hr == S_OK, "got %x\n", hr);
847 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
848 ok(V_I4(&v) == (STATE_SYSTEM_FOCUSABLE|STATE_SYSTEM_INVISIBLE),
849 "V_I4(&v) = %x\n", V_I4(&v));
850
851 str = (void*)0xdeadbeef;
852 hr = IAccessible_get_accHelp(acc, vid, &str);
853 ok(hr == S_FALSE, "got %x\n", hr);
854 ok(!str, "str != NULL\n");
855
856 hr = IAccessible_get_accKeyboardShortcut(acc, vid, &str);
857 ok(hr == S_OK, "got %x\n", hr);
858 ok(!lstrcmpW(str, shortcutW), "str = %s\n", wine_dbgstr_w(str));
859 SysFreeString(str);
860
861 str = (void*)0xdeadbeef;
862 hr = IAccessible_get_accDefaultAction(acc, vid, &str);
863 ok(hr == S_FALSE, "got %x\n", hr);
864 ok(!str, "str != NULL\n");
865
866 pt.x = pt.y = 60;
867 ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
868 hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
869 ok(hr == S_OK, "got %x\n", hr);
870 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
871 ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
872
873 pt.x = pt.y = 25;
874 ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
875 hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
876 ok(hr == S_OK, "got %x\n", hr);
877 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
878 ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
879
880 ShowWindow(hwnd, TRUE);
881 pt.x = pt.y = 60;
882 ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
883 hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
884 ok(hr == S_OK, "got %x\n", hr);
885 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
886 ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
887
888 pt.x = pt.y = 25;
889 ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
890 hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
891 ok(hr == S_OK, "got %x\n", hr);
892 ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
893 ok(V_DISPATCH(&v) != NULL, "V_DISPATCH(&v) = %p\n", V_DISPATCH(&v));
894 VariantClear(&v);
895
896 ShowWindow(chld, FALSE);
897 pt.x = pt.y = 25;
898 ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
899 hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
900 ok(hr == S_OK, "got %x\n", hr);
901 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
902 ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
903
904 hr = IAccessible_get_accParent(acc, &disp);
905 ok(hr == S_OK, "got %x\n", hr);
906 ok(disp != NULL, "disp == NULL\n");
907 IDispatch_Release(disp);
908
909 ok(GetClientRect(hwnd, &rect), "GetClientRect failed\n");
910 pt.x = rect.left;
911 pt.y = rect.top;
912 MapWindowPoints(hwnd, NULL, &pt, 1);
913 rect.left = pt.x;
914 rect.top = pt.y;
915 pt.x = rect.right;
916 pt.y = rect.bottom;
917 MapWindowPoints(hwnd, NULL, &pt, 1);
918 hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
919 ok(hr == S_OK, "got %x\n", hr);
920 ok(left == rect.left, "left = %d, expected %d\n", left, rect.left);
921 ok(top == rect.top, "top = %d, expected %d\n", top, rect.top);
922 ok(width == pt.x-rect.left, "width = %d, expected %d\n", width, pt.x-rect.left);
923 ok(height == pt.y-rect.top, "height = %d, expected %d\n", height, pt.y-rect.top);
924
925 DestroyWindow(hwnd);
926
927 hr = IAccessible_get_accChildCount(acc, &l);
928 ok(hr == S_OK, "got %x\n", hr);
929 ok(l == 0, "l = %d\n", l);
930
931 hr = IAccessible_get_accName(acc, vid, &str);
932 ok(hr == E_INVALIDARG, "got %x\n", hr);
933
934 hr = IAccessible_get_accValue(acc, vid, &str);
935 ok(hr == S_FALSE, "got %x\n", hr);
936
937 hr = IAccessible_get_accRole(acc, vid, &v);
938 ok(hr == S_OK, "got %x\n", hr);
939 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
940 ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
941
942 hr = IAccessible_get_accState(acc, vid, &v);
943 ok(hr == S_OK, "got %x\n", hr);
944 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
945 ok(V_I4(&v) == STATE_SYSTEM_INVISIBLE, "V_I4(&v) = %x\n", V_I4(&v));
946
947 hr = IAccessible_accHitTest(acc, 200, 200, &v);
948 ok(hr == S_OK, "got %x\n", hr);
949 ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
950 ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
951
952 disp = (void*)0xdeadbeef;
953 hr = IAccessible_get_accParent(acc, &disp);
954 ok(hr == E_FAIL, "got %x\n", hr);
955 ok(disp == NULL, "disp = %p\n", disp);
956
957 hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
958 ok(hr == S_OK, "got %x\n", hr);
959 ok(left == 0, "left = %d\n", left);
960 ok(top == 0, "top = %d\n", top);
961 ok(width == 0, "width = %d\n", width);
962 ok(height == 0, "height = %d\n", height);
963
964 IAccessible_Release(acc);
965 }
966
967 static void test_CAccPropServices(void)
968 {
969 IAccPropServices *acc_prop_services;
970 HRESULT hres;
971
972 hres = CoCreateInstance(&CLSID_CAccPropServices, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
973 &IID_IAccPropServices, (void**)&acc_prop_services);
974 ok(hres == S_OK, "Could not create CAccPropServices instance: %08x\n", hres);
975
976 IAccPropServices_Release(acc_prop_services);
977 }
978
979 START_TEST(main)
980 {
981 int argc;
982 char **argv;
983
984 if(!init())
985 return;
986
987 CoInitializeEx(NULL, COINIT_MULTITHREADED);
988
989 argc = winetest_get_mainargs(&argv);
990 if(argc == 4 && !strcmp(argv[2], "ObjectFromLresult")) {
991 IUnknown *unk;
992 HRESULT hres;
993 LRESULT lres;
994
995 lres = _strtoi64( argv[3], NULL, 16 );
996 hres = ObjectFromLresult(lres, &IID_IUnknown, 0, (void**)&unk);
997 ok(hres == S_OK, "hres = %x\n", hres);
998 IUnknown_Release(unk);
999
1000 CoUninitialize();
1001 return;
1002 }
1003
1004 if(!register_window_class()) {
1005 skip("can't register test window class\n");
1006 return;
1007 }
1008
1009 test_getroletext();
1010 test_GetStateText();
1011 test_LresultFromObject(argv[0]);
1012 test_AccessibleObjectFromWindow();
1013 test_GetProcessHandleFromHwnd();
1014 test_default_client_accessible_object();
1015 test_AccessibleChildren(&Accessible);
1016
1017 unregister_window_class();
1018 CoUninitialize();
1019
1020 CoInitialize(NULL);
1021 test_CAccPropServices();
1022 CoUninitialize();
1023 }