Signed-off-by: Connor McAdams cmcadams@codeweavers.com --- -This might technically be a v5, but since the AccessibleObjectFromEvent patch was accepted and not the tests, I've not marked this v5.
dlls/oleacc/tests/main.c | 994 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 994 insertions(+)
diff --git a/dlls/oleacc/tests/main.c b/dlls/oleacc/tests/main.c index ce44e06abe4..34498d2b3fe 100644 --- a/dlls/oleacc/tests/main.c +++ b/dlls/oleacc/tests/main.c @@ -304,6 +304,772 @@ static IAccessibleVtbl AccessibleVtbl = {
static IAccessible Accessible = {&AccessibleVtbl};
+/* + * Create an accessibility tree that looks like this: + * --ACC_TREE_OBJ_ID_ROOT (Full object) + * ----ACC_TREE_OBJ_ID_CHILD_0 (Full object) + * ----ACC_TREE_OBJ_ID_CHILD_1 (Full object) + * ------ACC_TREE_OBJ_ID_CHILD_1_0 (Simple element) + * ------ACC_TREE_OBJ_ID_CHILD_1_1 (Full object) + * ----ACC_TREE_OBJ_ID_CHILD_2 (Simple element) + */ +enum { + ACC_TREE_OBJ_ID_NONE = -1, + ACC_TREE_OBJ_ID_ROOT = 1, + ACC_TREE_OBJ_ID_CHILD_0, + ACC_TREE_OBJ_ID_CHILD_1, + ACC_TREE_OBJ_ID_CHILD_1_0, + ACC_TREE_OBJ_ID_CHILD_1_1, + ACC_TREE_OBJ_ID_CHILD_2, +}; + +typedef struct { + const WCHAR *name; + + INT parent_id, child_id, child_pos; + BOOL is_simple_elem; + UINT child_count; +} acc_tree_object_info; + +typedef struct { + IAccessible IAccessible_iface; + IEnumVARIANT IEnumVARIANT_iface; + + LONG ref; + + const acc_tree_object_info *info; + + HWND hwnd; + UINT enum_pos; + + IAccessible *parent; + IAccessible *children[3]; +} AccTreeObject; + +static AccTreeObject *object_tree = NULL; +static BOOL acc_query_interface_test_fail = FALSE; + +const acc_tree_object_info acc_from_event_obj_tree[] = { + { .name = L"acc_tree_root", + .parent_id = ACC_TREE_OBJ_ID_NONE, + .child_id = ACC_TREE_OBJ_ID_ROOT, + .child_pos = 0, + .child_count = 3, + .is_simple_elem = FALSE, + }, + { .name = L"acc_tree_child_0", + .parent_id = ACC_TREE_OBJ_ID_ROOT, + .child_id = ACC_TREE_OBJ_ID_CHILD_0, + .child_pos = 0, + .child_count = 0, + .is_simple_elem = FALSE, + }, + { .name = L"acc_tree_child_1", + .parent_id = ACC_TREE_OBJ_ID_ROOT, + .child_id = ACC_TREE_OBJ_ID_CHILD_1, + .child_pos = 1, + .child_count = 2, + .is_simple_elem = FALSE, + }, + { .name = L"acc_tree_child_1_0", + .parent_id = ACC_TREE_OBJ_ID_CHILD_1, + .child_id = ACC_TREE_OBJ_ID_CHILD_1_0, + .child_pos = 0, + .child_count = 0, + .is_simple_elem = TRUE, + }, + { .name = L"acc_tree_child_1_1", + .parent_id = ACC_TREE_OBJ_ID_CHILD_1, + .child_id = ACC_TREE_OBJ_ID_CHILD_1_1, + .child_pos = 1, + .child_count = 0, + .is_simple_elem = FALSE, + }, + { .name = L"acc_tree_child_2", + .parent_id = ACC_TREE_OBJ_ID_ROOT, + .child_id = ACC_TREE_OBJ_ID_CHILD_2, + .child_pos = 2, + .child_count = 0, + .is_simple_elem = TRUE, + }, +}; + +/* + * AccTreeObj IAccessible Vtbl. + */ +static inline AccTreeObject* impl_from_AccTreeObject(IAccessible *iface) +{ + return CONTAINING_RECORD(iface, AccTreeObject, IAccessible_iface); +} + +static IAccessible *get_acc_tree_obj_child(IAccessible *iface, VARIANT child_id) +{ + AccTreeObject *obj = impl_from_AccTreeObject(iface); + IAccessible *acc = NULL; + LONG i; + + if (V_VT(&child_id) != VT_I4) + return NULL; + + if (V_I4(&child_id) == CHILDID_SELF) + { + IAccessible_AddRef(iface); + return iface; + } + + for (i = 0; i < obj->info->child_count; i++) + { + AccTreeObject *child = impl_from_AccTreeObject(obj->children[i]); + + if (child->info->child_id == V_I4(&child_id)) + { + acc = &child->IAccessible_iface; + break; + } + } + + if (acc) + IAccessible_AddRef(acc); + + return acc; +} + +static void check_acc_tree_obj_for_child(IAccessible *acc, + INT child_id, IAccessible **found_acc, VARIANT *found_vid) +{ + IDispatch *disp_child; + VARIANT vid; + HRESULT hr; + + V_VT(&vid) = VT_I4; + V_I4(&vid) = child_id; + hr = IAccessible_get_accChild(acc, vid, &disp_child); + if (SUCCEEDED(hr)) + { + /* + * If S_FALSE is returned, the childID was found, but it's a simple + * element. + */ + if (hr == S_FALSE) + { + *found_acc = acc; + V_VT(found_vid) = VT_I4; + V_I4(found_vid) = child_id; + } + else + { + IDispatch_QueryInterface(disp_child, &IID_IAccessible, + (void **)found_acc); + V_VT(found_vid) = VT_I4; + V_I4(found_vid) = CHILDID_SELF; + IDispatch_Release(disp_child); + } + } +} + +static void search_acc_tree_for_child_enumVARIANT(IAccessible *acc, + INT child_id, IAccessible **found_acc, VARIANT *found_vid) +{ + LONG child_cnt, i, rcv; + VARIANT *children; + HRESULT hr; + + IAccessible_get_accChildCount(acc, &child_cnt); + if (!child_cnt) + return; + + check_acc_tree_obj_for_child(acc, child_id, found_acc, found_vid); + if (*found_acc) + return; + + children = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + sizeof(*children) * child_cnt); + hr = AccessibleChildren(acc, 0, child_cnt, children, &rcv); + ok(hr == S_OK, "AccessibleChildren failed with %#x!\n", hr); + + /* + * We only care about VT_DISPATCH VARIANT's here, because simple elements + * cannot have children, and if they were a match it would've been found + * in check_acc_tree_obj_for_child(). + */ + for (i = 0; i < child_cnt; i++) + { + VARIANT *res = &children[i]; + IAccessible *acc_child; + + if (V_VT(res) != VT_DISPATCH) + continue; + + if (!(*found_acc)) + { + hr = IDispatch_QueryInterface(V_DISPATCH(res), &IID_IAccessible, (void **)&acc_child); + if (SUCCEEDED(hr)) + search_acc_tree_for_child_enumVARIANT(acc_child, child_id, found_acc, found_vid); + + if (*found_acc != acc_child) + IAccessible_Release(acc_child); + } + + IDispatch_Release(V_DISPATCH(res)); + } + + HeapFree(GetProcessHeap(), 0, (void *)children); +} + +static void search_acc_tree_for_child_navigate(IAccessible *acc, + INT child_id, IAccessible **found_acc, VARIANT *found_vid) +{ + VARIANT vid, res; + HRESULT hr; + + check_acc_tree_obj_for_child(acc, child_id, found_acc, found_vid); + if (*found_acc) + return; + + V_VT(&vid) = VT_I4; + V_I4(&vid) = CHILDID_SELF; + hr = IAccessible_accNavigate(acc, NAVDIR_FIRSTCHILD, vid, &res); + if (FAILED(hr)) + return; + + while (SUCCEEDED(hr) && V_VT(&res) != VT_EMPTY && !(*found_acc)) + { + switch (V_VT(&res)) + { + case VT_I4: + vid = res; + hr = IAccessible_accNavigate(acc, NAVDIR_NEXT, vid, &res); + break; + + case VT_DISPATCH: + { + IAccessible *acc_child; + + hr = IDispatch_QueryInterface(V_DISPATCH(&res), &IID_IAccessible, (void **)&acc_child); + IDispatch_Release(V_DISPATCH(&res)); + + if (SUCCEEDED(hr)) + { + search_acc_tree_for_child_navigate(acc_child, child_id, found_acc, found_vid); + + if (!(*found_acc)) + { + V_VT(&vid) = VT_I4; + V_I4(&vid) = CHILDID_SELF; + hr = IAccessible_accNavigate(acc_child, NAVDIR_NEXT, vid, &res); + } + + if (*found_acc != acc_child) + IAccessible_Release(acc_child); + } + break; + } + + default: + ok(0, "Invalid VARIANT type %d from accNavigate\n", V_VT(&res)); + return; + } + } +} + +HRESULT WINAPI AccTreeObject_QueryInterface(IAccessible *iface, REFIID riid, void **ppv) +{ + AccTreeObject *This = impl_from_AccTreeObject(iface); + + if((IsEqualIID(riid, &IID_IAccessible) && !acc_query_interface_test_fail) || + IsEqualIID(riid, &IID_IDispatch) || + IsEqualIID(riid, &IID_IUnknown)) { + *ppv = iface; + }else if(IsEqualIID(riid, &IID_IEnumVARIANT)) { + *ppv = &This->IEnumVARIANT_iface; + }else { + *ppv = NULL; + return E_NOINTERFACE; + } + + IAccessible_AddRef(iface); + return S_OK; +} + +ULONG WINAPI AccTreeObject_AddRef(IAccessible *iface) +{ + AccTreeObject *This = impl_from_AccTreeObject(iface); + return InterlockedIncrement(&This->ref); +} + +ULONG WINAPI AccTreeObject_Release(IAccessible *iface) +{ + AccTreeObject *This = impl_from_AccTreeObject(iface); + return InterlockedDecrement(&This->ref); +} + +HRESULT WINAPI AccTreeObject_GetTypeInfoCount( + IAccessible *iface, UINT *pctinfo) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_GetTypeInfo(IAccessible *iface, + UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_GetIDsOfNames(IAccessible *iface, REFIID riid, + LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_Invoke(IAccessible *iface, DISPID dispIdMember, + REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, + VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accParent( + IAccessible *iface, IDispatch **disp_parent) +{ + AccTreeObject *This = impl_from_AccTreeObject(iface); + + if (This->parent) + return IAccessible_QueryInterface(This->parent, &IID_IDispatch, (void **)disp_parent); + *disp_parent = NULL; + + return S_FALSE; +} + +HRESULT WINAPI AccTreeObject_get_accChildCount( + IAccessible *iface, LONG *pcountChildren) +{ + AccTreeObject *This = impl_from_AccTreeObject(iface); + + *pcountChildren = This->info->child_count; + + return S_OK; +} + +HRESULT WINAPI AccTreeObject_get_accChild(IAccessible *iface, + VARIANT varChildID, IDispatch **ppdispChild) +{ + IAccessible *child; + AccTreeObject *obj; + HRESULT hr; + + *ppdispChild = NULL; + if (!(child = get_acc_tree_obj_child(iface, varChildID))) + return E_INVALIDARG; + + obj = impl_from_AccTreeObject(child); + if (obj->info->is_simple_elem) + { + IAccessible_Release(child); + return S_FALSE; + } + + if (FAILED(hr = IAccessible_QueryInterface(child, &IID_IDispatch, (void **)ppdispChild))) + return hr; + + IAccessible_Release(child); + + return S_OK; +} + +HRESULT WINAPI AccTreeObject_get_accName(IAccessible *iface, + VARIANT varID, BSTR *pszName) +{ + IAccessible *child; + AccTreeObject *obj; + + *pszName = NULL; + if (!(child = get_acc_tree_obj_child(iface, varID))) + return E_INVALIDARG; + + obj = impl_from_AccTreeObject(child); + *pszName = SysAllocString(obj->info->name); + IAccessible_Release(child); + + return S_OK; +} + +HRESULT WINAPI AccTreeObject_get_accValue(IAccessible *iface, + VARIANT varID, BSTR *pszValue) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accDescription(IAccessible *iface, + VARIANT varID, BSTR *pszDescription) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accRole(IAccessible *iface, + VARIANT varID, VARIANT *pvarRole) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accState(IAccessible *iface, + VARIANT varID, VARIANT *pvarState) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accHelp(IAccessible *iface, + VARIANT varID, BSTR *pszHelp) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accHelpTopic(IAccessible *iface, + BSTR *pszHelpFile, VARIANT varID, LONG *pidTopic) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accKeyboardShortcut(IAccessible *iface, + VARIANT varID, BSTR *pszKeyboardShortcut) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accFocus(IAccessible *iface, VARIANT *pvarID) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accSelection( + IAccessible *iface, VARIANT *pvarID) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_get_accDefaultAction(IAccessible *iface, + VARIANT varID, BSTR *pszDefaultAction) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_accSelect(IAccessible *iface, + LONG flagsSelect, VARIANT varID) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_accLocation(IAccessible *iface, LONG *pxLeft, + LONG *pyTop, LONG *pcxWidth, LONG *pcyHeight, VARIANT varID) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_accNavigate(IAccessible *iface, + LONG navDir, VARIANT varStart, VARIANT *pvarEnd) +{ + AccTreeObject *This = impl_from_AccTreeObject(iface); + AccTreeObject *obj_start, *child; + IAccessible *acc_start; + HRESULT hr = S_FALSE; + + V_VT(pvarEnd) = VT_EMPTY; + if (!(acc_start = get_acc_tree_obj_child(iface, varStart))) + return E_INVALIDARG; + + child = NULL; + obj_start = impl_from_AccTreeObject(acc_start); + switch (navDir) + { + case NAVDIR_FIRSTCHILD: + case NAVDIR_LASTCHILD: + { + UINT child_cnt = obj_start->info->child_count; + + /* Cannot start with a child ID offset when getting first/last children. */ + if ((V_I4(&varStart) == CHILDID_SELF) && child_cnt) + { + if (navDir == NAVDIR_FIRSTCHILD) + child = impl_from_AccTreeObject(obj_start->children[0]); + else + child = impl_from_AccTreeObject(obj_start->children[child_cnt - 1]); + } + break; + } + + case NAVDIR_NEXT: + case NAVDIR_PREVIOUS: + { + AccTreeObject *parent; + INT next_pos; + + if (!obj_start->parent) + break; + + if (V_I4(&varStart) == CHILDID_SELF) + parent = impl_from_AccTreeObject(obj_start->parent); + else + parent = This; + + if (navDir == NAVDIR_PREVIOUS) + next_pos = obj_start->info->child_pos - 1; + else + next_pos = obj_start->info->child_pos + 1; + + if ((next_pos < 0) || (parent->info->child_count <= next_pos)) + break; + + child = impl_from_AccTreeObject(parent->children[next_pos]); + break; + } + + default: + break; + } + + if (child) + { + if (child->info->is_simple_elem) + { + V_VT(pvarEnd) = VT_I4; + V_I4(pvarEnd) = child->info->child_id; + } + else + { + V_VT(pvarEnd) = VT_DISPATCH; + IAccessible_QueryInterface(&child->IAccessible_iface, + &IID_IDispatch, (void **)&V_DISPATCH(pvarEnd)); + } + + hr = S_OK; + } + + if (acc_start) + IAccessible_Release(acc_start); + + return hr; +} + +HRESULT WINAPI AccTreeObject_accHitTest(IAccessible *iface, + LONG xLeft, LONG yTop, VARIANT *pvarID) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_accDoDefaultAction( + IAccessible *iface, VARIANT varID) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_put_accName(IAccessible *iface, + VARIANT varID, BSTR pszName) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +HRESULT WINAPI AccTreeObject_put_accValue(IAccessible *iface, + VARIANT varID, BSTR pszValue) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +IAccessibleVtbl AccTreeObjAccessibleVtbl = { + AccTreeObject_QueryInterface, + AccTreeObject_AddRef, + AccTreeObject_Release, + AccTreeObject_GetTypeInfoCount, + AccTreeObject_GetTypeInfo, + AccTreeObject_GetIDsOfNames, + AccTreeObject_Invoke, + AccTreeObject_get_accParent, + AccTreeObject_get_accChildCount, + AccTreeObject_get_accChild, + AccTreeObject_get_accName, + AccTreeObject_get_accValue, + AccTreeObject_get_accDescription, + AccTreeObject_get_accRole, + AccTreeObject_get_accState, + AccTreeObject_get_accHelp, + AccTreeObject_get_accHelpTopic, + AccTreeObject_get_accKeyboardShortcut, + AccTreeObject_get_accFocus, + AccTreeObject_get_accSelection, + AccTreeObject_get_accDefaultAction, + AccTreeObject_accSelect, + AccTreeObject_accLocation, + AccTreeObject_accNavigate, + AccTreeObject_accHitTest, + AccTreeObject_accDoDefaultAction, + AccTreeObject_put_accName, + AccTreeObject_put_accValue +}; + +/* + * AccTreeObj enumVARIANT Vtbl. + */ +inline AccTreeObject* impl_from_AccTreeObject_EnumVARIANT(IEnumVARIANT *iface) +{ + return CONTAINING_RECORD(iface, AccTreeObject, IEnumVARIANT_iface); +} + +HRESULT WINAPI AccTreeObject_EnumVARIANT_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **ppv) +{ + AccTreeObject *This = impl_from_AccTreeObject_EnumVARIANT(iface); + return IAccessible_QueryInterface(&This->IAccessible_iface, riid, ppv); +} + +ULONG WINAPI AccTreeObject_EnumVARIANT_AddRef(IEnumVARIANT *iface) +{ + AccTreeObject *This = impl_from_AccTreeObject_EnumVARIANT(iface); + return IAccessible_AddRef(&This->IAccessible_iface); +} + +ULONG WINAPI AccTreeObject_EnumVARIANT_Release(IEnumVARIANT *iface) +{ + AccTreeObject *This = impl_from_AccTreeObject_EnumVARIANT(iface); + return IAccessible_Release(&This->IAccessible_iface); +} + +HRESULT WINAPI AccTreeObject_EnumVARIANT_Next(IEnumVARIANT *iface, + ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched) +{ + AccTreeObject *This = impl_from_AccTreeObject_EnumVARIANT(iface); + ULONG fetched = 0; + UINT i; + + for (i = This->enum_pos; i < This->info->child_count; i++) + { + AccTreeObject *child = impl_from_AccTreeObject(This->children[i]); + + if (child->info->is_simple_elem) + { + V_VT(&rgVar[i]) = VT_I4; + V_I4(&rgVar[i]) = child->info->child_id; + } + else + { + V_VT(&rgVar[i]) = VT_DISPATCH; + IAccessible_QueryInterface(&child->IAccessible_iface, &IID_IDispatch, + (void **)&V_DISPATCH(&rgVar[i])); + } + + fetched++; + } + + *pCeltFetched = fetched; + + return celt == fetched ? S_OK : S_FALSE; +} + +HRESULT WINAPI AccTreeObject_EnumVARIANT_Skip(IEnumVARIANT *iface, ULONG celt) +{ + AccTreeObject *This = impl_from_AccTreeObject_EnumVARIANT(iface); + + if ((celt + This->enum_pos) < This->info->child_count) + { + This->enum_pos += celt; + return S_OK; + } + + return S_FALSE; +} + +HRESULT WINAPI AccTreeObject_EnumVARIANT_Reset(IEnumVARIANT *iface) +{ + AccTreeObject *This = impl_from_AccTreeObject_EnumVARIANT(iface); + + This->enum_pos = 0; + + return S_OK; +} + +HRESULT WINAPI AccTreeObject_EnumVARIANT_Clone(IEnumVARIANT *iface, IEnumVARIANT **ppEnum) +{ + ok(0, "unexpected call\n"); + return E_NOTIMPL; +} + +const IEnumVARIANTVtbl AccTreeObjEnumVARIANTVtbl = { + AccTreeObject_EnumVARIANT_QueryInterface, + AccTreeObject_EnumVARIANT_AddRef, + AccTreeObject_EnumVARIANT_Release, + AccTreeObject_EnumVARIANT_Next, + AccTreeObject_EnumVARIANT_Skip, + AccTreeObject_EnumVARIANT_Reset, + AccTreeObject_EnumVARIANT_Clone +}; + +static HRESULT create_acc_obj_tree(const acc_tree_object_info *info, + unsigned int count) +{ + AccTreeObject *tree_objs; + unsigned int i; + + object_tree = NULL; + + tree_objs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + sizeof(*tree_objs) * count); + if (!tree_objs) + return E_OUTOFMEMORY; + + for (i = 0; i < count; i++) + { + const acc_tree_object_info *cur_obj = &info[i]; + AccTreeObject *obj = &tree_objs[i]; + + obj->IAccessible_iface.lpVtbl = &AccTreeObjAccessibleVtbl; + obj->IEnumVARIANT_iface.lpVtbl = &AccTreeObjEnumVARIANTVtbl; + obj->ref = 1; + obj->info = cur_obj; + + if (cur_obj->parent_id != ACC_TREE_OBJ_ID_NONE) + { + AccTreeObject *parent = &tree_objs[cur_obj->parent_id - 1]; + + obj->parent = &parent->IAccessible_iface; + parent->children[cur_obj->child_pos] = &obj->IAccessible_iface; + } + } + + object_tree = tree_objs; + + return S_OK; +} + +static void free_acc_obj_tree(unsigned int count) +{ + unsigned int i; + + if (!object_tree) + return; + + for (i = 0; i < count; i++) + IAccessible_Release(&object_tree[i].IAccessible_iface); + + HeapFree(GetProcessHeap(), 0, object_tree); + object_tree = NULL; +} + static void test_getroletext(void) { INT ret, role; @@ -564,7 +1330,13 @@ static LRESULT WINAPI test_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARA if(lparam == (DWORD)OBJID_CURSOR) return E_UNEXPECTED; if(lparam == (DWORD)OBJID_CLIENT) + { + if (object_tree) + return LresultFromObject(&IID_IAccessible, wparam, + (IUnknown *)&object_tree->IAccessible_iface); + return LresultFromObject(&IID_IUnknown, wparam, &Object); + } if(lparam == (DWORD)OBJID_WINDOW) return 0;
@@ -621,6 +1393,227 @@ static void test_AccessibleObjectFromWindow(void) DestroyWindow(hwnd); }
+static void test_AccessibleObjectFromEvent(void) +{ + IAccessible *acc, *acc_child; + const WCHAR *expected_name; + BSTR obj_name; + VARIANT cid; + HRESULT hr; + HWND hwnd; + + hwnd = CreateWindowA("oleacc_test", "test", WS_OVERLAPPEDWINDOW, + 0, 0, 0, 0, NULL, NULL, NULL, NULL); + ok(hwnd != NULL, "CreateWindow failed\n"); + + hr = create_acc_obj_tree(acc_from_event_obj_tree, + ARRAY_SIZE(acc_from_event_obj_tree)); + ok(hr == S_OK, "failed to create accessible object tree, hr %#x\n", hr); + + hr = AccessibleObjectFromEvent(NULL, OBJID_CLIENT, CHILDID_SELF, &acc, &cid); + ok(hr == E_FAIL, "got %#x\n", hr); + + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, CHILDID_SELF, NULL, &cid); + ok(hr == E_INVALIDARG, "got %#x\n", hr); + + /* + * Test get_accChild's IDispatch::QueryInterface failing to return an + * IAccessible interface. + */ + acc_query_interface_test_fail = TRUE; + acc = NULL; + VariantInit(&cid); + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, CHILDID_SELF, &acc, &cid); + ok(hr == E_NOINTERFACE, "got %#x\n", hr); + ok(acc == NULL, "Unexpected acc %p\n", acc); + ok(V_VT(&cid) == VT_EMPTY, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + acc_query_interface_test_fail = FALSE; + + /* Same behavior as AccessibleObjectFromWindow. */ + hr = AccessibleObjectFromEvent(hwnd, OBJID_CURSOR, CHILDID_SELF, &acc, &cid); + ok(hr == E_UNEXPECTED, "got %#x\n", hr); + + /* Get a full object child. */ + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, ACC_TREE_OBJ_ID_CHILD_0, &acc, &cid); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(V_VT(&cid) == VT_I4, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + ok(V_I4(&cid) == CHILDID_SELF, "got %#x, expected %#x\n", V_I4(&cid), CHILDID_SELF); + + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_CHILD_0 - 1].name; + hr = IAccessible_get_accName(acc, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc); + + /* Get a 'simple element' child. */ + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, ACC_TREE_OBJ_ID_CHILD_2, &acc, &cid); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(V_VT(&cid) == VT_I4, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + ok(V_I4(&cid) == ACC_TREE_OBJ_ID_CHILD_2, "got %#x, expected %#x\n", V_I4(&cid), ACC_TREE_OBJ_ID_CHILD_2); + + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_CHILD_2 - 1].name; + hr = IAccessible_get_accName(acc, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + + /* + * Make sure the IAccessible returned for a simple element is the + * root IAccessible. + */ + V_I4(&cid) = CHILDID_SELF; + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_ROOT - 1].name; + hr = IAccessible_get_accName(acc, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc); + + /* + * Invalid child ID's are treated by AccessibleObjectFromEvent as simple + * elements, regardless of if get_accChild returns a failure code instead + * of S_FALSE to indicate a simple element. The IAccessible returned is + * the root object, and child ID is still set to the invalid child ID. + */ + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, ACC_TREE_OBJ_ID_CHILD_2 + 1, &acc, &cid); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(V_VT(&cid) == VT_I4, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + ok(V_I4(&cid) == (ACC_TREE_OBJ_ID_CHILD_2 + 1), "got %#x, expected %#x\n", + V_I4(&cid), ACC_TREE_OBJ_ID_CHILD_2 + 1); + + V_VT(&cid) = VT_I4; + V_I4(&cid) = CHILDID_SELF; + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_ROOT - 1].name; + hr = IAccessible_get_accName(acc, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc); + + /* + * AccessibleObjectFromEvent will not search an object tree for a child, + * so if a given child ID is not returned by the get_accChild method on the + * root IAccessible, it won't be found by AccessibleObjectFromEvent. This + * is an issue in things such as web browsers, where one HWND is used as a + * root object with a complex tree of objects within it. + */ + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, ACC_TREE_OBJ_ID_CHILD_1_0, &acc, &cid); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(V_VT(&cid) == VT_I4, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + ok(V_I4(&cid) == (ACC_TREE_OBJ_ID_CHILD_1_0), "got %#x, expected %#x\n", + V_I4(&cid), ACC_TREE_OBJ_ID_CHILD_1_0); + + V_VT(&cid) = VT_I4; + V_I4(&cid) = CHILDID_SELF; + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_ROOT - 1].name; + hr = IAccessible_get_accName(acc, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc); + + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, ACC_TREE_OBJ_ID_CHILD_1_1, &acc, &cid); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(V_VT(&cid) == VT_I4, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + ok(V_I4(&cid) == (ACC_TREE_OBJ_ID_CHILD_1_1), "got %#x, expected %#x\n", + V_I4(&cid), ACC_TREE_OBJ_ID_CHILD_1_1); + + V_VT(&cid) = VT_I4; + V_I4(&cid) = CHILDID_SELF; + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_ROOT - 1].name; + hr = IAccessible_get_accName(acc, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc); + + /* + * Show that ACC_TREE_OBJ_ID_CHILD_1's children are actually reachable + * from the root IAccessible using both possible methods of traversing + * the IAccessible tree (accNavigate and AccessibleChildren). + */ + hr = AccessibleObjectFromEvent(hwnd, OBJID_CLIENT, CHILDID_SELF, &acc, &cid); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(V_VT(&cid) == VT_I4, "got %#x, expected %#x\n", V_VT(&cid), VT_I4); + ok(V_I4(&cid) == CHILDID_SELF, "got %#x, expected %#x\n", V_I4(&cid), CHILDID_SELF); + + /* IAccessible_accNavigate method. */ + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + acc_child = NULL; + search_acc_tree_for_child_navigate(acc, ACC_TREE_OBJ_ID_CHILD_1_0, &acc_child, &cid); + ok(!!acc_child, "Failed to find child id %#x in tree!\n", ACC_TREE_OBJ_ID_CHILD_1_0); + + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_CHILD_1_0 - 1].name; + hr = IAccessible_get_accName(acc_child, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc_child); + + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + acc_child = NULL; + search_acc_tree_for_child_navigate(acc, ACC_TREE_OBJ_ID_CHILD_1_1, &acc_child, &cid); + ok(!!acc_child, "Failed to find child id %#x in tree!\n", ACC_TREE_OBJ_ID_CHILD_1_1); + + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_CHILD_1_1 - 1].name; + hr = IAccessible_get_accName(acc_child, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc_child); + + /* AccessibleChildren (IEnumVARIANT) method. */ + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + acc_child = NULL; + search_acc_tree_for_child_enumVARIANT(acc, ACC_TREE_OBJ_ID_CHILD_1_0, &acc_child, &cid); + ok(!!acc_child, "Failed to find child id %#x in tree!\n", ACC_TREE_OBJ_ID_CHILD_1_0); + + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_CHILD_1_0 - 1].name; + hr = IAccessible_get_accName(acc_child, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc_child); + + V_I4(&cid) = 0; + V_VT(&cid) = VT_EMPTY; + acc_child = NULL; + search_acc_tree_for_child_enumVARIANT(acc, ACC_TREE_OBJ_ID_CHILD_1_1, &acc_child, &cid); + ok(!!acc_child, "Failed to find child id %#x in tree!\n", ACC_TREE_OBJ_ID_CHILD_1_1); + + expected_name = acc_from_event_obj_tree[ACC_TREE_OBJ_ID_CHILD_1_1 - 1].name; + hr = IAccessible_get_accName(acc_child, cid, &obj_name); + ok(SUCCEEDED(hr), "got %#x\n", hr); + ok(!lstrcmpW(obj_name, expected_name), "expected %s, got %s\n", + wine_dbgstr_w(expected_name), wine_dbgstr_w(obj_name)); + SysFreeString(obj_name); + IAccessible_Release(acc_child); + + IAccessible_Release(acc); + + DestroyWindow(hwnd); + free_acc_obj_tree(ARRAY_SIZE(acc_from_event_obj_tree)); +} + static void test_GetProcessHandleFromHwnd(void) { HANDLE proc; @@ -1061,6 +2054,7 @@ START_TEST(main) test_GetProcessHandleFromHwnd(); test_default_client_accessible_object(); test_AccessibleChildren(&Accessible); + test_AccessibleObjectFromEvent();
unregister_window_class(); CoUninitialize();