dlls/oleacc/tests/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 static HANDLE (WINAPI *pGetProcessHandleFromHwnd)(HWND);
  30
  31 static BOOL init(void)
  32 {
  33     HMODULE oleacc = GetModuleHandleA("oleacc.dll");
  34
  35     pGetProcessHandleFromHwnd = (void*)GetProcAddress(oleacc, "GetProcessHandleFromHwnd");
  36     if(!pGetProcessHandleFromHwnd) {
  37         win_skip("GetProcessHandleFromHwnd not available\n");
  38         return FALSE;
  39     }
  40
  41     return TRUE;
  42 }
  43
  44 static void test_getroletext(void)
  45 {
  46     INT ret, role;
  47     CHAR buf[2], *buff;
  48     WCHAR bufW[2], *buffW;
  49
  50     /* wrong role number */
  51     ret = GetRoleTextA(-1, NULL, 0);
  52     ok(ret == 0, "GetRoleTextA doesn't return zero on wrong role number, got %d\n", ret);
  53     buf[0] = '*';
  54     ret = GetRoleTextA(-1, buf, 2);
  55     ok(ret == 0, "GetRoleTextA doesn't return zero on wrong role number, got %d\n", ret);
  56     ok(buf[0] == 0, "GetRoleTextA doesn't return NULL char on wrong role number\n");
  57     buf[0] = '*';
  58     ret = GetRoleTextA(-1, buf, 0);
  59     ok(ret == 0, "GetRoleTextA doesn't return zero on wrong role number, got %d\n", ret);
  60     ok(buf[0] == '*', "GetRoleTextA modified buffer on wrong role number\n");
  61
  62     ret = GetRoleTextW(-1, NULL, 0);
  63     ok(ret == 0, "GetRoleTextW doesn't return zero on wrong role number, got %d\n", ret);
  64     bufW[0] = '*';
  65     ret = GetRoleTextW(-1, bufW, 2);
  66     ok(ret == 0, "GetRoleTextW doesn't return zero on wrong role number, got %d\n", ret);
  67     ok(bufW[0] == '\0', "GetRoleTextW doesn't return NULL char on wrong role number\n");
  68     bufW[0] = '*';
  69     ret = GetRoleTextW(-1, bufW, 0);
  70     ok(ret == 0, "GetRoleTextW doesn't return zero on wrong role number, got %d\n", ret);
  71
  72     /* zero role number - not documented */
  73     ret = GetRoleTextA(0, NULL, 0);
  74     ok(ret > 0, "GetRoleTextA doesn't return (>0) for zero role number, got %d\n", ret);
  75     ret = GetRoleTextW(0, NULL, 0);
  76     ok(ret > 0, "GetRoleTextW doesn't return (>0) for zero role number, got %d\n", ret);
  77
  78     /* NULL buffer, return length */
  79     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, NULL, 0);
  80     ok(ret > 0, "GetRoleTextA doesn't return length on NULL buffer, got %d\n", ret);
  81     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, NULL, 1);
  82     ok(ret > 0, "GetRoleTextA doesn't return length on NULL buffer, got %d\n", ret);
  83     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, NULL, 0);
  84     ok(ret > 0, "GetRoleTextW doesn't return length on NULL buffer, got %d\n", ret);
  85     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, NULL, 1);
  86     ok(ret > 0, "GetRoleTextW doesn't return length on NULL buffer, got %d\n", ret);
  87
  88     /* use a smaller buffer */
  89     bufW[0] = '*';
  90     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buf, 0);
  91     ok(!ret, "GetRoleTextA doesn't return 0, got %d\n", ret);
  92     ok(buf[0] == '*', "GetRoleTextA modified buffer\n");
  93     buffW = NULL;
  94     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, (WCHAR*)&buffW, 0);
  95     ok(ret, "GetRoleTextW doesn't return length\n");
  96     ok(buffW != NULL, "GetRoleTextW doesn't modify buffer\n");
  97     buf[0] = '*';
  98     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buf, 1);
  99     ok(ret == 0, "GetRoleTextA returned wrong length\n");
 100     ok(buf[0] == '\0', "GetRoleTextA returned not zero-length buffer\n");
 101     buf[0] = '*';
 102     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buf, 2);
 103     ok(!ret, "GetRoleTextA returned wrong length, got %d, expected 0\n", ret);
 104     ok(!buf[0] || broken(buf[0]!='*') /* WinXP */,
 105             "GetRoleTextA returned not zero-length buffer : (%c)\n", buf[0]);
 106
 107     bufW[0] = '*';
 108     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, bufW, 1);
 109     ok(ret == 0, "GetRoleTextW returned wrong length, got %d, expected 1\n", ret);
 110     ok(bufW[0] == '\0', "GetRoleTextW returned not zero-length buffer\n");
 111     bufW[1] = '*';
 112     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, bufW, 2);
 113     ok(ret == 1, "GetRoleTextW returned wrong length, got %d, expected 1\n", ret);
 114     ok(bufW[1] == '\0', "GetRoleTextW returned not zero-length buffer\n");
 115
 116     /* use bigger buffer */
 117     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, NULL, 0);
 118     buff = HeapAlloc(GetProcessHeap(), 0, 2*ret);
 119     buff[2*ret-1] = '*';
 120     ret = GetRoleTextA(ROLE_SYSTEM_TITLEBAR, buff, 2*ret);
 121     ok(buff[2*ret-1] == '*', "GetRoleTextA shouldn't modify this part of buffer\n");
 122     HeapFree(GetProcessHeap(), 0, buff);
 123
 124     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, NULL, 0);
 125     buffW = HeapAlloc(GetProcessHeap(), 0, 2*ret*sizeof(WCHAR));
 126     buffW[2*ret-1] = '*';
 127     ret = GetRoleTextW(ROLE_SYSTEM_TITLEBAR, buffW, 2*ret);
 128     ok(buffW[2*ret-1] == '*', "GetRoleTextW shouldn't modify this part of buffer\n");
 129     HeapFree(GetProcessHeap(), 0, buffW);
 130
 131     /* check returned length for all roles */
 132     for(role = 0; role <= ROLE_SYSTEM_OUTLINEBUTTON; role++){
 133         CHAR buff2[100];
 134         WCHAR buff2W[100];
 135
 136         /* NT4 and W2K don't clear the buffer on a nonexistent role in the A-call */
 137         memset(buff2, 0, sizeof(buff2));
 138
 139         ret = GetRoleTextA(role, NULL, 0);
 140         ok(ret > 0, "Expected the role to be present\n");
 141
 142         GetRoleTextA(role, buff2, sizeof(buff2));
 143         ok(ret == lstrlenA(buff2),
 144            "GetRoleTextA: returned length doesn't match returned buffer for role %d\n", role);
 145
 146         /* Win98 and WinMe don't clear the buffer on a nonexistent role in the W-call */
 147         memset(buff2W, 0, sizeof(buff2W));
 148
 149         ret = GetRoleTextW(role, NULL, 0);
 150         GetRoleTextW(role, buff2W, sizeof(buff2W)/sizeof(WCHAR));
 151         ok(ret == lstrlenW(buff2W),
 152            "GetRoleTextW: returned length doesn't match returned buffer for role %d\n", role);
 153     }
 154 }
 155
 156 static void test_GetStateText(void)
 157 {
 158     WCHAR buf[1024], buf2[1024];
 159     char bufa[1024];
 160     void *ptr;
 161     UINT ret, ret2;
 162     int i;
 163
 164     ret2 = GetStateTextW(0, NULL, 1024);
 165     ok(ret2, "GetStateText failed\n");
 166
 167     ptr = NULL;
 168     ret = GetStateTextW(0, (WCHAR*)&ptr, 0);
 169     ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
 170     ok(ptr != NULL, "ptr was not changed\n");
 171
 172     ret = GetStateTextW(0, buf, 1024);
 173     ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
 174     ok(!memcmp(buf, ptr, ret*sizeof(WCHAR)), "got %s, expected %s\n",
 175             wine_dbgstr_wn(buf, ret), wine_dbgstr_wn(ptr, ret));
 176
 177     ret = GetStateTextW(0, buf, 1);
 178     ok(!ret, "got %d, expected 0\n", ret);
 179     ok(!buf[0], "buf[0] = '%c'\n", buf[0]);
 180
 181     for(i=0; i<31; i++) {
 182         ret = GetStateTextW(1<<i, buf, 1024);
 183         ok(ret, "%d) GetStateText failed\n", i);
 184     }
 185     ret = GetStateTextW(1<<31, buf, 1024);
 186     ok(!ret, "31) GetStateText succeeded: %d\n", ret);
 187
 188     ret = GetStateTextW(2, buf, 1024);
 189     ok(ret, "GetStateText failed\n");
 190     ret2 = GetStateTextW(3, buf2, 1024);
 191     ok(ret2, "GetStateText failed\n");
 192     ok(ret == ret2, "got %d, expected %d\n", ret2, ret);
 193     ok(!memcmp(buf, buf2, ret*sizeof(WCHAR)),
 194             "GetStateText(2,...) returned different data than GetStateText(3,...)\n");
 195
 196     ret2 = GetStateTextA(0, NULL, 1024);
 197     ok(ret2, "GetStateText failed\n");
 198
 199     ptr = NULL;
 200     ret = GetStateTextA(0, (CHAR*)&ptr, 0);
 201     ok(!ret, "got %d\n", ret);
 202     ok(ptr == NULL, "ptr was changed\n");
 203
 204     ret = GetStateTextA(0, NULL, 0);
 205     ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
 206
 207     ret = GetStateTextA(0, bufa, 1024);
 208     ok(ret == ret2, "got %d, expected %d\n", ret, ret2);
 209
 210     ret = GetStateTextA(0, bufa, 1);
 211     ok(!ret, "got %d, expected 0\n", ret);
 212     ok(!bufa[0], "bufa[0] = '%c'\n", bufa[0]);
 213
 214     for(i=0; i<31; i++) {
 215         ret = GetStateTextA(1<<i, bufa, 1024);
 216         ok(ret, "%d) GetStateText failed\n", i);
 217     }
 218     ret = GetStateTextA(1<<31, bufa, 1024);
 219     ok(!ret, "31) GetStateText succeeded: %d\n", ret);
 220 }
 221
 222 static int Object_ref = 1;
 223 static HRESULT WINAPI Object_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 224 {
 225     if(IsEqualIID(riid, &IID_IUnknown)) {
 226         *ppv = iface;
 227         IUnknown_AddRef(iface);
 228         return S_OK;
 229     }
 230     return E_NOINTERFACE;
 231 }
 232
 233 static ULONG WINAPI Object_AddRef(IUnknown *iface)
 234 {
 235     return InterlockedIncrement(&Object_ref);
 236 }
 237
 238 static ULONG WINAPI Object_Release(IUnknown *iface)
 239 {
 240     return InterlockedDecrement(&Object_ref);
 241 }
 242
 243 static IUnknownVtbl ObjectVtbl = {
 244     Object_QueryInterface,
 245     Object_AddRef,
 246     Object_Release
 247 };
 248
 249 static IUnknown Object = {&ObjectVtbl};
 250
 251 static void test_LresultFromObject(const char *name)
 252 {
 253     PROCESS_INFORMATION proc;
 254     STARTUPINFOA startup;
 255     char cmdline[MAX_PATH];
 256     IUnknown *unk;
 257     HRESULT hres;
 258     LRESULT lres;
 259
 260     lres = LresultFromObject(NULL, 0, 0);
 261     ok(lres == E_INVALIDARG, "got %lx\n", lres);
 262
 263     hres = ObjectFromLresult(0, &IID_IUnknown, 0, (void**)&unk);
 264     ok(hres == E_FAIL, "got %x\n", hres);
 265     hres = ObjectFromLresult(0x10000, &IID_IUnknown, 0, (void**)&unk);
 266     ok(hres == E_FAIL, "got %x\n", hres);
 267
 268     ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
 269     lres = LresultFromObject(&IID_IUnknown, 0, &Object);
 270     ok(SUCCEEDED(lres), "got %lx\n", lres);
 271     ok(Object_ref > 1, "Object_ref = %d\n", Object_ref);
 272
 273     hres = ObjectFromLresult(lres, &IID_IUnknown, 0, (void**)&unk);
 274     ok(hres == S_OK, "hres = %x\n", hres);
 275     ok(unk == &Object, "unk != &Object\n");
 276     IUnknown_Release(unk);
 277     ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
 278
 279     lres = LresultFromObject(&IID_IUnknown, 0, &Object);
 280     ok(SUCCEEDED(lres), "got %lx\n", lres);
 281     ok(Object_ref > 1, "Object_ref = %d\n", Object_ref);
 282
 283     sprintf(cmdline, "\"%s\" main ObjectFromLresult %lx", name, lres);
 284     memset(&startup, 0, sizeof(startup));
 285     startup.cb = sizeof(startup);
 286     CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &proc);
 287     winetest_wait_child_process(proc.hProcess);
 288     ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
 289 }
 290
 291 static LRESULT WINAPI test_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 292 {
 293     switch(msg) {
 294     case WM_GETOBJECT:
 295         if(lparam == OBJID_QUERYCLASSNAMEIDX) {
 296             ok(!wparam, "wparam = %lx\n", wparam);
 297             return 0;
 298         }
 299
 300         ok(wparam==0xffffffff, "wparam = %lx\n", wparam);
 301         if(lparam == (DWORD)OBJID_CURSOR)
 302             return E_UNEXPECTED;
 303         if(lparam == (DWORD)OBJID_CLIENT)
 304             return LresultFromObject(&IID_IUnknown, wparam, &Object);
 305         if(lparam == (DWORD)OBJID_WINDOW)
 306             return 0;
 307
 308         ok(0, "unexpected (%ld)\n", lparam);
 309         return 0;
 310     }
 311
 312     return DefWindowProcA(hwnd, msg, wparam, lparam);
 313 }
 314
 315 static BOOL register_window_class(void)
 316 {
 317     WNDCLASSA cls;
 318
 319     memset(&cls, 0, sizeof(cls));
 320     cls.lpfnWndProc = test_window_proc;
 321     cls.lpszClassName = "oleacc_test";
 322     cls.hInstance = GetModuleHandleA(NULL);
 323
 324     return RegisterClassA(&cls);
 325 }
 326
 327 static void unregister_window_class(void)
 328 {
 329     UnregisterClassA("oleacc_test", NULL);
 330 }
 331
 332 static void test_AccessibleObjectFromWindow(void)
 333 {
 334     IUnknown *unk;
 335     HRESULT hr;
 336     HWND hwnd;
 337
 338     hr = AccessibleObjectFromWindow(NULL, OBJID_CURSOR, &IID_IUnknown, NULL);
 339     ok(hr == E_INVALIDARG, "got %x\n", hr);
 340
 341     hr = AccessibleObjectFromWindow(NULL, OBJID_CURSOR, &IID_IUnknown, (void**)&unk);
 342     todo_wine ok(hr == S_OK, "got %x\n", hr);
 343     if(hr == S_OK) IUnknown_Release(unk);
 344
 345     hwnd = CreateWindowA("oleacc_test", "test", WS_OVERLAPPEDWINDOW,
 346             0, 0, 0, 0, NULL, NULL, NULL, NULL);
 347     ok(hwnd != NULL, "CreateWindow failed\n");
 348
 349     hr = AccessibleObjectFromWindow(hwnd, OBJID_CURSOR, &IID_IUnknown, (void**)&unk);
 350     ok(hr == E_UNEXPECTED, "got %x\n", hr);
 351
 352     ok(Object_ref == 1, "Object_ref = %d\n", Object_ref);
 353     hr = AccessibleObjectFromWindow(hwnd, OBJID_CLIENT, &IID_IUnknown, (void**)&unk);
 354     ok(hr == S_OK, "got %x\n", hr);
 355     ok(Object_ref == 2, "Object_ref = %d\n", Object_ref);
 356     IUnknown_Release(unk);
 357
 358     DestroyWindow(hwnd);
 359 }
 360
 361 static void test_GetProcessHandleFromHwnd(void)
 362 {
 363     HANDLE proc;
 364     HWND hwnd;
 365
 366     proc = pGetProcessHandleFromHwnd(NULL);
 367     ok(!proc, "proc = %p\n", proc);
 368
 369     hwnd = CreateWindowA("static", "", 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
 370     ok(hwnd != NULL, "CreateWindow failed\n");
 371
 372     proc = pGetProcessHandleFromHwnd(hwnd);
 373     ok(proc != NULL, "proc == NULL\n");
 374     CloseHandle(proc);
 375
 376     DestroyWindow(hwnd);
 377 }
 378
 379 static void test_default_client_accessible_object(void)
 380 {
 381     static const WCHAR testW[] = {'t','e','s','t',' ','t',' ','&','j','u','n','k',0};
 382     static const WCHAR shortcutW[] = {'A','l','t','+','t',0};
 383
 384     IAccessible *acc;
 385     IDispatch *disp;
 386     IOleWindow *ow;
 387     HWND chld, hwnd, hwnd2;
 388     HRESULT hr;
 389     VARIANT vid, v;
 390     BSTR str;
 391     POINT pt;
 392     RECT rect;
 393     LONG l, left, top, width, height;
 394
 395     hwnd = CreateWindowA("oleacc_test", "test &t &junk", WS_OVERLAPPEDWINDOW,
 396             0, 0, 100, 100, NULL, NULL, NULL, NULL);
 397     ok(hwnd != NULL, "CreateWindow failed\n");
 398     chld = CreateWindowA("static", "message", WS_CHILD | WS_VISIBLE,
 399             0, 0, 50, 50, hwnd, NULL, NULL, NULL);
 400     ok(chld != NULL, "CreateWindow failed\n");
 401
 402     hr = CreateStdAccessibleObject(NULL, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
 403     ok(hr == E_FAIL, "got %x\n", hr);
 404
 405     hr = CreateStdAccessibleObject(hwnd, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
 406     ok(hr == S_OK, "got %x\n", hr);
 407
 408     hr = IAccessible_QueryInterface(acc, &IID_IOleWindow, (void**)&ow);
 409     ok(hr == S_OK, "got %x\n", hr);
 410     hr = IOleWindow_GetWindow(ow, &hwnd2);
 411     ok(hr == S_OK, "got %x\n", hr);
 412     ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
 413     hr = WindowFromAccessibleObject(acc, &hwnd2);
 414     ok(hr == S_OK, "got %x\n", hr);
 415     ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
 416     IOleWindow_Release(ow);
 417
 418     hr = IAccessible_get_accChildCount(acc, &l);
 419     ok(hr == S_OK, "got %x\n", hr);
 420     ok(l == 1, "l = %d\n", l);
 421
 422     V_VT(&vid) = VT_I4;
 423     V_I4(&vid) = CHILDID_SELF;
 424     hr = IAccessible_get_accName(acc, vid, &str);
 425     ok(hr == S_OK, "got %x\n", hr);
 426     ok(!lstrcmpW(str, testW), "name = %s\n", wine_dbgstr_w(str));
 427     SysFreeString(str);
 428
 429     V_I4(&vid) = 1;
 430     str = (void*)0xdeadbeef;
 431     hr = IAccessible_get_accName(acc, vid, &str);
 432     ok(hr == E_INVALIDARG, "got %x\n", hr);
 433     ok(!str, "str != NULL\n");
 434     V_I4(&vid) = CHILDID_SELF;
 435
 436     str = (void*)0xdeadbeef;
 437     hr = IAccessible_get_accValue(acc, vid, &str);
 438     ok(hr == S_FALSE, "got %x\n", hr);
 439     ok(!str, "str != NULL\n");
 440
 441     str = (void*)0xdeadbeef;
 442     hr = IAccessible_get_accDescription(acc, vid, &str);
 443     ok(hr == S_FALSE, "got %x\n", hr);
 444     ok(!str, "str != NULL\n");
 445
 446     V_VT(&v) = VT_DISPATCH;
 447     V_DISPATCH(&v) = (void*)0xdeadbeef;
 448     hr = IAccessible_get_accRole(acc, vid, &v);
 449     ok(hr == S_OK, "got %x\n", hr);
 450     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 451     ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
 452
 453     V_VT(&v) = VT_DISPATCH;
 454     V_DISPATCH(&v) = (void*)0xdeadbeef;
 455     hr = IAccessible_get_accState(acc, vid, &v);
 456     ok(hr == S_OK, "got %x\n", hr);
 457     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 458     ok(V_I4(&v) == (STATE_SYSTEM_FOCUSABLE|STATE_SYSTEM_INVISIBLE),
 459             "V_I4(&v) = %x\n", V_I4(&v));
 460
 461     str = (void*)0xdeadbeef;
 462     hr = IAccessible_get_accHelp(acc, vid, &str);
 463     ok(hr == S_FALSE, "got %x\n", hr);
 464     ok(!str, "str != NULL\n");
 465
 466     hr = IAccessible_get_accKeyboardShortcut(acc, vid, &str);
 467     ok(hr == S_OK, "got %x\n", hr);
 468     ok(!lstrcmpW(str, shortcutW), "str = %s\n", wine_dbgstr_w(str));
 469     SysFreeString(str);
 470
 471     str = (void*)0xdeadbeef;
 472     hr = IAccessible_get_accDefaultAction(acc, vid, &str);
 473     ok(hr == S_FALSE, "got %x\n", hr);
 474     ok(!str, "str != NULL\n");
 475
 476     pt.x = pt.y = 60;
 477     ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
 478     hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
 479     ok(hr == S_OK, "got %x\n", hr);
 480     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 481     ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
 482
 483     pt.x = pt.y = 25;
 484     ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
 485     hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
 486     ok(hr == S_OK, "got %x\n", hr);
 487     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 488     ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
 489
 490     ShowWindow(hwnd, TRUE);
 491     pt.x = pt.y = 60;
 492     ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
 493     hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
 494     ok(hr == S_OK, "got %x\n", hr);
 495     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 496     ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
 497
 498     pt.x = pt.y = 25;
 499     ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
 500     hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
 501     ok(hr == S_OK, "got %x\n", hr);
 502     ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
 503     ok(V_DISPATCH(&v) != NULL, "V_DISPATCH(&v) = %p\n", V_DISPATCH(&v));
 504     VariantClear(&v);
 505
 506     ShowWindow(chld, FALSE);
 507     pt.x = pt.y = 25;
 508     ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
 509     hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
 510     ok(hr == S_OK, "got %x\n", hr);
 511     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 512     ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
 513
 514     hr = IAccessible_get_accParent(acc, &disp);
 515     ok(hr == S_OK, "got %x\n", hr);
 516     ok(disp != NULL, "disp == NULL\n");
 517     IDispatch_Release(disp);
 518
 519     ok(GetClientRect(hwnd, &rect), "GetClientRect failed\n");
 520     pt.x = rect.left;
 521     pt.y = rect.top;
 522     MapWindowPoints(hwnd, NULL, &pt, 1);
 523     rect.left = pt.x;
 524     rect.top = pt.y;
 525     pt.x = rect.right;
 526     pt.y = rect.bottom;
 527     MapWindowPoints(hwnd, NULL, &pt, 1);
 528     hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
 529     ok(hr == S_OK, "got %x\n", hr);
 530     ok(left == rect.left, "left = %d, expected %d\n", left, rect.left);
 531     ok(top == rect.top, "top = %d, expected %d\n", top, rect.top);
 532     ok(width == pt.x-rect.left, "width = %d, expected %d\n", width, pt.x-rect.left);
 533     ok(height == pt.y-rect.top, "height = %d, expected %d\n", height, pt.y-rect.top);
 534
 535     DestroyWindow(hwnd);
 536
 537     hr = IAccessible_get_accChildCount(acc, &l);
 538     ok(hr == S_OK, "got %x\n", hr);
 539     ok(l == 0, "l = %d\n", l);
 540
 541     hr = IAccessible_get_accName(acc, vid, &str);
 542     ok(hr == E_INVALIDARG, "got %x\n", hr);
 543
 544     hr = IAccessible_get_accValue(acc, vid, &str);
 545     ok(hr == S_FALSE, "got %x\n", hr);
 546
 547     hr = IAccessible_get_accRole(acc, vid, &v);
 548     ok(hr == S_OK, "got %x\n", hr);
 549     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 550     ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
 551
 552     hr = IAccessible_get_accState(acc, vid, &v);
 553     ok(hr == S_OK, "got %x\n", hr);
 554     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 555     ok(V_I4(&v) == STATE_SYSTEM_INVISIBLE, "V_I4(&v) = %x\n", V_I4(&v));
 556
 557     hr = IAccessible_accHitTest(acc, 200, 200, &v);
 558     ok(hr == S_OK, "got %x\n", hr);
 559     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 560     ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
 561
 562     disp = (void*)0xdeadbeef;
 563     hr = IAccessible_get_accParent(acc, &disp);
 564     ok(hr == E_FAIL, "got %x\n", hr);
 565     ok(disp == NULL, "disp = %p\n", disp);
 566
 567     hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
 568     ok(hr == S_OK, "got %x\n", hr);
 569     ok(left == 0, "left =  %d\n", left);
 570     ok(top == 0, "top =  %d\n", top);
 571     ok(width == 0, "width =  %d\n", width);
 572     ok(height == 0, "height =  %d\n", height);
 573
 574     IAccessible_Release(acc);
 575 }
 576
 577 START_TEST(main)
 578 {
 579     int argc;
 580     char **argv;
 581
 582     if(!init())
 583         return;
 584
 585     CoInitializeEx(NULL, COINIT_MULTITHREADED);
 586
 587     argc = winetest_get_mainargs(&argv);
 588     if(argc == 4 && !strcmp(argv[2], "ObjectFromLresult")) {
 589         IUnknown *unk;
 590         HRESULT hres;
 591         LRESULT lres;
 592
 593         sscanf(argv[3], "%lx", &lres);
 594         hres = ObjectFromLresult(lres, &IID_IUnknown, 0, (void**)&unk);
 595         ok(hres == S_OK, "hres = %x\n", hres);
 596         IUnknown_Release(unk);
 597
 598         CoUninitialize();
 599         return;
 600     }
 601
 602     if(!register_window_class()) {
 603         skip("can't register test window class\n");
 604         return;
 605     }
 606
 607     test_getroletext();
 608     test_GetStateText();
 609     test_LresultFromObject(argv[0]);
 610     test_AccessibleObjectFromWindow();
 611     test_GetProcessHandleFromHwnd();
 612     test_default_client_accessible_object();
 613
 614     unregister_window_class();
 615     CoUninitialize();
 616 }