From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- .../ifc/accessibility/_XAccessibleSelection.java | 586 +++++++++++++++++++++ 1 file changed, 586 insertions(+) create mode 100644 qadevOOo/tests/java/ifc/accessibility/_XAccessibleSelection.java (limited to 'qadevOOo/tests/java/ifc/accessibility/_XAccessibleSelection.java') diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleSelection.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleSelection.java new file mode 100644 index 000000000..edbf477c9 --- /dev/null +++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleSelection.java @@ -0,0 +1,586 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +package ifc.accessibility; + +import com.sun.star.accessibility.AccessibleRole; +import com.sun.star.accessibility.XAccessible; +import com.sun.star.accessibility.XAccessibleContext; +import com.sun.star.accessibility.XAccessibleSelection; +import com.sun.star.uno.UnoRuntime; + +import lib.MultiMethodTest; +import lib.Status; +import lib.StatusException; + + +/** + * Testing com.sun.star.accessibility.XAccessibleSelection + * interface methods : + *

+ * + * This test needs the following object relations : + *

+ * + * @see com.sun.star.accessibility.XAccessibleSelection + */ +public class _XAccessibleSelection extends MultiMethodTest { + private static final String className = "com.sun.star.accessibility.XAccessibleSelection"; + public XAccessibleSelection oObj = null; + XAccessibleContext xAC = null; + int childCount; + protected boolean multiSelection = true; + protected boolean OneAlwaysSelected = false; + + // temporary while accessibility package is in com.sun.star + @Override + protected String getTestedClassName() { + return className; + } + + /** + * Retrieves the interface XAccessibleContext + * and object relation. + * @see com.sun.star.accessibility.XAccessibleContext + * @see ifc.accessibility._XAccessibleContext + */ + @Override + protected void before() { + xAC = UnoRuntime.queryInterface( + XAccessibleContext.class, oObj); + + if (xAC == null) { + throw new StatusException(Status.failed( + "Couldn't query XAccessibleContext. Test must be modified")); + } + + Boolean b = (Boolean) tEnv.getObjRelation( + "XAccessibleSelection.multiSelection"); + + if (b != null) { + multiSelection = b.booleanValue(); + } + + Boolean b2 = (Boolean) tEnv.getObjRelation( + "XAccessibleSelection.OneAlwaysSelected"); + + if (b2 != null) { + OneAlwaysSelected = b2.booleanValue(); + } + + childCount = xAC.getAccessibleChildCount(); + log.println("Child count: " + childCount); + } + + /** + * Selects accessible child with index some wrong indexes + * and with legal index. + * Has OK status if exception was thrown for wrong indexes + * and if exception wasn't thrown for correct index. + */ + public void _selectAccessibleChild() { + boolean res = true; + + try { + log.println("Try to select child with index " + childCount); + oObj.selectAccessibleChild(childCount); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res = true; + } + + try { + log.println("Try to select child with index -1"); + oObj.selectAccessibleChild(-1); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res &= true; + } + + log.println("ChildCount: " + childCount); + + int usedChildren = childCount; + + if (childCount > 500) { + log.println("Restricting to 500"); + usedChildren = 500; + } + + if (usedChildren > 0) { + try { + for (int i = 0; i < usedChildren; i++) { + log.print("Trying to select child with index " + i + ": "); + + if (isSelectable(tEnv.getTestObject(), i)) { + oObj.selectAccessibleChild(i); + log.println("OK"); + } else { + log.println("Child isn't selectable"); + } + } + + res &= true; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception"); + e.printStackTrace(log); + res = false; + } + } + + tRes.tested("selectAccessibleChild()", res); + } + + /** + * Calls the method with the wrong index and with the correct index. + * Has OK status if exception was thrown for wrong index and + * if exception wasn't thrown for the correct index. + */ + public void _isAccessibleChildSelected() throws Exception { + executeMethod("selectAccessibleChild()"); + + boolean res = true; + boolean isSelected = false; + + try { + log.print("isAccessibleChildSelected(-1)? "); + isSelected = oObj.isAccessibleChildSelected(-1); + log.println(res); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res = true; + } + + try { + log.print("isAccessibleChildSelected(" + childCount + ")? "); + isSelected = oObj.isAccessibleChildSelected(childCount); + log.println(isSelected); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res &= true; + } + + int SelectableChildCount = chkSelectable(tEnv.getTestObject()); + + if (SelectableChildCount > 500) { + SelectableChildCount = 500; + } + + log.println("SelectableChildCount: " + SelectableChildCount); + + if (SelectableChildCount > 0) { + try { + oObj.selectAllAccessibleChildren(); + + for (int k = 0; k < SelectableChildCount; k++) { + log.println("Trying to select child with index " + k); + + if (isSelectable(tEnv.getTestObject(), k)) { + oObj.selectAccessibleChild(k); + waitForEventIdle(); + isSelected = oObj.isAccessibleChildSelected(k); + log.println("isAccessibleChildSelected - " + + isSelected); + res &= isSelected; + } else { + log.println("Child isn't selectable"); + } + } + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception"); + e.printStackTrace(log); + res = false; + } + } + + tRes.tested("isAccessibleChildSelected()", res); + } + + /** + * Calls the method. + * Has OK status if the method isAccessibleChildSelected() + * returned false. + */ + public void _clearAccessibleSelection() throws Exception { + executeMethod("isAccessibleChildSelected()"); + + boolean res = true; + + log.println("clearAccessibleSelection"); + oObj.clearAccessibleSelection(); + + + // clearAccessibleSelection() call is oneway so we need + // some waiting + waitForEventIdle(); + + if ((childCount > 0) && !OneAlwaysSelected) { + try { + log.print("isAccessibleChildSelected(" + (childCount - 1) + + ")? "); + + boolean isSel = oObj.isAccessibleChildSelected(childCount - 1); + log.println(isSel); + res = !isSel; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception"); + e.printStackTrace(log); + res = false; + } + } else if (OneAlwaysSelected) { + log.println("Can't clear selection, one child is always selected"); + } + + tRes.tested("clearAccessibleSelection()", res); + } + + /** + * Calls the method. + * Has OK status if the method isAccessibleChildSelected() + * returns true for first and for last accessible child + * or if multiselection is not allowed. + */ + public void _selectAllAccessibleChildren() { + executeMethod("clearAccessibleSelection()"); + + log.println("selectAllAccessibleChildren..."); + oObj.selectAllAccessibleChildren(); + + + // selectAllAccessibleChildren() call is oneway so we need + // some waiting + waitForEventIdle(); + + boolean res = true; + boolean isSelected = true; + + int SelectableChildCount = chkSelectable(tEnv.getTestObject()); + + if ((SelectableChildCount > 0) && multiSelection) { + try { + log.print("isAccessibleChildSelected(1)? "); + isSelected = oObj.isAccessibleChildSelected(1); + log.println(isSelected); + res = isSelected; + + log.print("isAccessibleChildSelected(" + (childCount - 1) + + ")? "); + isSelected = oObj.isAccessibleChildSelected(childCount - 1); + log.println(isSelected); + res &= isSelected; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception"); + e.printStackTrace(log); + res = false; + } + } + + tRes.tested("selectAllAccessibleChildren()", res); + } + + /** + * Calls the method. Clears accessible selection and calls the method again. + *

+ * Has OK status if the method returns number equal to number of accessible + * child count after first call if multiselection allowed, or + * 1 returned if multiselection not allowed. + * And if the method returns a zero after clearing selection. + */ + public void _getSelectedAccessibleChildCount() { + log.println("getSelectedAccessibleChildCount():"); + + if (multiSelection) { + oObj.selectAllAccessibleChildren(); + } else { + int usedChildren = childCount; + + if (childCount > 500) { + log.println("Restricting to 500"); + usedChildren = 500; + } + + if (usedChildren > 0) { + try { + for (int i = 0; i < usedChildren; i++) { + + if (isSelectable(tEnv.getTestObject(), i)) { + log.print("Trying to select child with index "+i+": "); + oObj.selectAccessibleChild(i); + long curtime = System.currentTimeMillis(); + long checktime = System.currentTimeMillis(); + + while (!oObj.isAccessibleChildSelected(i) && (checktime-curtime<5000)) { + checktime = System.currentTimeMillis(); + } + + log.println("OK"); + } + } + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception"); + e.printStackTrace(log); + } + } + } + + int sCount = chkSelectable(tEnv.getTestObject()); + log.println("Found " + sCount + " selectable Children"); + + int selectedCount = oObj.getSelectedAccessibleChildCount(); + log.println("After selecting all accessible " + selectedCount + + " are selected"); + + boolean res = true; + + if (multiSelection) { + res &= (selectedCount == sCount); + } else { + res &= (selectedCount == 1); + } + + log.println("clearAccessibleSelection..."); + oObj.clearAccessibleSelection(); + log.print("getSelectedAccessibleChildCount: "); + selectedCount = oObj.getSelectedAccessibleChildCount(); + log.println(selectedCount); + + if (OneAlwaysSelected) { + res &= (selectedCount == 1); + } else { + res &= (selectedCount == 0); + } + + tRes.tested("getSelectedAccessibleChildCount()", res); + } + + /** + * Calls the method with wrong and correct indexes. + * Has OK status if exception was thrown for the wrong indexes, + * if exception wasn't thrown for the correct index and + * if the method have returned a not null for the correct index. + */ + public void _getSelectedAccessibleChild() throws Exception { + executeMethod("getSelectedAccessibleChildCount()"); + + boolean res = true; + int selectedCount = oObj.getSelectedAccessibleChildCount(); + log.println("getSelectedAccessibleChildCount: " + selectedCount); + + try { + log.println("getSelectedAccessibleChild(-1)"); + oObj.getSelectedAccessibleChild(-1); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res = true; + } + + try { + log.println("getSelectedAccessibleChild(" + selectedCount + ")"); + oObj.getSelectedAccessibleChild(selectedCount); + log.println("Exception was expected"); + res &= false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res &= true; + } + + int SelectableChildCount = chkSelectable(tEnv.getTestObject()); + + if (SelectableChildCount > 500) { + SelectableChildCount = 500; + } + + if (SelectableChildCount > 0) { + int k = 0; + try { + for (k = 0; k < SelectableChildCount; k++) { + log.println("Trying to select child with index " + k); + + if (isSelectable(tEnv.getTestObject(), k)) { + oObj.selectAccessibleChild(k); + waitForEventIdle(); + log.println("selected child count: " + + oObj.getSelectedAccessibleChildCount()); + XAccessible selChild = oObj.getSelectedAccessibleChild(0); + res &= (selChild != null); + log.println("valid child - " + (selChild != null)); + } else { + log.println("Child isn't selectable"); + } + } + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception: Last relevant calls:\n " + + "\toObj.selectAccessibleChild("+k+")\n" + + "\toObj.getSelectedAccessibleChild(0)"); + e.printStackTrace(log); + res = false; + } + } + + tRes.tested("getSelectedAccessibleChild()", res); + } + + /** + * Calls the method with wrong and with correct indexes. + * Has OK status if exceptions were thrown for the calls with + * the wrong indexes, if exception wasn't thrown for the call + * with correct index and if number of selected child was + * decreased after the correct call. + */ + public void _deselectAccessibleChild() { + executeMethod("getSelectedAccessibleChild()"); + + boolean res = true; + int selCount = oObj.getSelectedAccessibleChildCount(); + log.println("getSelectedAccessibleChildCount():" + selCount); + + try { + log.println("deselectAccessibleChild(-1)"); + oObj.deselectAccessibleChild(-1); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res &= true; + } + + try { + log.println("deselectAccessibleChild(" + (childCount + 1) + ")"); + oObj.deselectAccessibleChild(childCount + 1); + log.println("Exception was expected"); + res = false; + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Expected exception"); + res &= true; + } + + log.println("#################"); + log.println("Selecting all accessible"); + oObj.selectAllAccessibleChildren(); + selCount = oObj.getSelectedAccessibleChildCount(); + log.println("getSelectedAccessibleChildCount():" + selCount); + + if ((childCount > 0) && (selCount > 0)) { + try { + int maxCount = chkSelectable(tEnv.getTestObject()); + + if (childCount > 100) { + maxCount = 100; + } + + for (int k = 0; k < maxCount; k++) { + log.println("deselectAccessibleChild(" + k + ")"); + + if (oObj.isAccessibleChildSelected(k)) { + oObj.deselectAccessibleChild(k); + } + } + + int newSelCount = oObj.getSelectedAccessibleChildCount(); + log.println("getSelectedAccessibleChildCount():" + + newSelCount); + + if (OneAlwaysSelected && (selCount == 1)) { + log.println("One Child is always selected"); + res &= true; + } else { + res &= (selCount > newSelCount); + } + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + log.println("Unexpected exception"); + e.printStackTrace(log); + res = false; + } + } + + tRes.tested("deselectAccessibleChild()", res); + } + + protected static int chkSelectable(Object Testcase) { + int ret = 0; + XAccessibleContext accCon = UnoRuntime.queryInterface( + XAccessibleContext.class, Testcase); + int cc = accCon.getAccessibleChildCount(); + + if (cc > 500) { + return cc; + } + + for (int i = 0; i < cc; i++) { + try { + if (accCon.getAccessibleChild(i).getAccessibleContext() + .getAccessibleStateSet() + .contains(com.sun.star.accessibility.AccessibleStateType.SELECTABLE)) { + ret = ret + 1; + System.out.println("Child " + i + " is selectable"); + } + } catch (com.sun.star.lang.IndexOutOfBoundsException iab) { + } + } + + return ret; + } + + protected static boolean isSelectable(Object Testcase, int index) { + XAccessibleContext accCon = UnoRuntime.queryInterface( + XAccessibleContext.class, Testcase); + boolean res = false; + + try { + if (accCon.getAccessibleChild(index).getAccessibleContext() + .getAccessibleStateSet() + .contains(com.sun.star.accessibility.AccessibleStateType.SELECTABLE)) { + res = true; + } + + //selecting menuitems or the separator will lead to closing the menu + if ((accCon.getAccessibleChild(index).getAccessibleContext() + .getAccessibleRole() == AccessibleRole.MENU_ITEM) || + (accCon.getAccessibleChild(index).getAccessibleContext() + .getAccessibleRole() == AccessibleRole.SEPARATOR)) { + res = false; + } + } catch (com.sun.star.lang.IndexOutOfBoundsException e) { + System.out.println("Exception while checking for selectability"); + } + + return res; + } +} -- cgit v1.2.3