Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

12 files changed, 5218 insertions, 0 deletions

diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessible.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessible.java
new file mode 100644
index 000000000..329ecc6ab
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessible.java
@@ -0,0 +1,48 @@
+/*
+ * 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 lib.MultiMethodTest;
+
+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleContext;
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessible</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> getAccessibleContext()</code></li>
+ * </ul> <p>
+ * @see com.sun.star.accessibility.XAccessible
+ */
+public class _XAccessible extends MultiMethodTest {
+
+
+    public XAccessible oObj = null;
+
+    /**
+     * Just calls the method. <p>
+     * Has <b> OK </b> status if not null value returned.
+     */
+    public void _getAccessibleContext() {
+        XAccessibleContext ac = oObj.getAccessibleContext();
+        tRes.tested("getAccessibleContext()",ac != null);
+    }
+
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleAction.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleAction.java
new file mode 100644
index 000000000..d83b231eb
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleAction.java
@@ -0,0 +1,159 @@
+/*
+ * 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.XAccessibleAction;
+
+public class _XAccessibleAction extends lib.MultiMethodTest {
+
+    public XAccessibleAction oObj = null;
+    public int count = 0;
+
+    /**
+     * calls the method and stores the result in the <br>
+     * variable count. It is OK if no exception occurs
+     */
+
+    public void _getAccessibleActionCount() {
+        count = oObj.getAccessibleActionCount();
+        tRes.tested("getAccessibleActionCount()",count > 0);
+    }
+
+    /**
+     * calls the method with invalid argument and check if the <br>
+     * expected Exception is thrown.<br>
+     * Calls the method afterwards the first valid parameter.<br>
+     * This is the last method called and the environment is disposed<br>
+     * afterwards.
+     */
+
+    public void _doAccessibleAction() {
+        requiredMethod("getAccessibleActionKeyBinding()");
+        boolean res = true;
+
+        log.println("Calling method with wrong argument");
+        try {
+            oObj.doAccessibleAction(count);
+            log.println("Exception expected -- FAILED");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException ioe) {
+            log.println("Expected exception -- OK");
+            res &= true;
+        }
+
+        try {
+            boolean act = false;
+            for (int i = 0; i< count; i++) {
+                log.println("do Action "+ oObj.getAccessibleActionDescription(i));
+                act = oObj.doAccessibleAction(i);
+                log.println("Worked: "+act);
+            }
+            log.println("Did action: "+act);
+            res &= act ;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException ioe) {
+            log.println("Unexpected exception -- FAILED");
+            res &= false;
+        }
+
+        tRes.tested("doAccessibleAction()",res);
+    }
+
+    /**
+     * calls the method with invalid argument and check if the <br>
+     * expected Exception is thrown.<br>
+     * Calls the method afterwards all valid parameters.<br>
+     * Is ok if the exception is thrown and the resulting value
+     * for the calls with valid parameters aren't null.
+     */
+
+    public void _getAccessibleActionDescription() {
+        requiredMethod("getAccessibleActionCount()");
+        boolean res = true;
+
+        log.println("Calling method with wrong argument");
+        try {
+            oObj.getAccessibleActionDescription(count);
+            log.println("Exception expected -- FAILED");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException ioe) {
+            log.println("Expected exception -- OK");
+            res &= true;
+        }
+
+        for (int i=0;i<count;i++) {
+            try {
+                String desc = oObj.getAccessibleActionDescription(i);
+                log.println("Found action: "+desc);
+                res &= desc!=null ;
+            } catch (com.sun.star.lang.IndexOutOfBoundsException ioe) {
+                log.println("Unexpected exception -- FAILED");
+                res &= false;
+            }
+        }
+
+        tRes.tested("getAccessibleActionDescription()",res);
+    }
+
+    /**
+     * calls the method with invalid argument and check if the <br>
+     * expected Exception is thrown.<br>
+     * Calls the method afterwards all valid parameters.<br>
+     * Is ok if the exception is thrown and the resulting value
+     * for the calls with valid parameters aren't null.
+     */
+
+    public void _getAccessibleActionKeyBinding() {
+        requiredMethod("getAccessibleActionDescription()");
+        boolean res = true;
+
+        log.println("Calling method with wrong argument");
+        try {
+            oObj.getAccessibleActionKeyBinding(count);
+            log.println("Exception expected -- FAILED");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException ioe) {
+            log.println("Expected exception -- OK");
+            res &= true;
+        }
+
+        for (int i=0;i<count;i++) {
+            try {
+                Object key = oObj.getAccessibleActionKeyBinding(i);
+                if (key != null ) {
+                    log.println("Found key: "+key.toString());
+                }
+                res &= true;
+            } catch (com.sun.star.lang.IndexOutOfBoundsException ioe) {
+                log.println("Unexpected exception -- FAILED");
+                res &= false;
+            }
+        }
+
+        tRes.tested("getAccessibleActionKeyBinding()",res);
+    }
+
+    /**
+    * Forces environment recreation.
+    */
+    @Override
+    protected void after() {
+        disposeEnvironment();
+    }
+
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleComponent.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleComponent.java
new file mode 100644
index 000000000..52dad6801
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleComponent.java
@@ -0,0 +1,601 @@
+/*
+ * 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 java.util.ArrayList;
+import lib.MultiMethodTest;
+
+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleComponent;
+import com.sun.star.accessibility.XAccessibleContext;
+import com.sun.star.awt.Point;
+import com.sun.star.awt.Rectangle;
+import com.sun.star.awt.Size;
+import com.sun.star.uno.UnoRuntime;
+
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleComponent</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> containsPoint()</code></li>
+ *  <li><code> getAccessibleAtPoint()</code></li>
+ *  <li><code> getBounds()</code></li>
+ *  <li><code> getLocation()</code></li>
+ *  <li><code> getLocationOnScreen()</code></li>
+ *  <li><code> getSize()</code></li>
+ *  <li><code> grabFocus()</code></li>
+ *  <li><code> getAccessibleKeyBinding()</code></li>
+ * </ul> <p>
+ *
+ * @see com.sun.star.accessibility.XAccessibleComponent
+ */
+public class _XAccessibleComponent extends MultiMethodTest {
+
+    public XAccessibleComponent oObj = null;
+    private final ArrayList<Rectangle> KnownBounds = new ArrayList<Rectangle>();
+
+
+    /**
+     * First checks 4 inner bounds (upper, lower, left and right)
+     * of component bounding box to contain
+     * at least one point of the component. Second 4 outer bounds
+     * are checked to not contain any component points.<p>
+     *
+     * Has <b> OK </b> status if inner bounds contain component points
+     * and outer bounds don't contain any component points. <p>
+     *
+     * The following method tests are to be completed successfully before :
+     * <ul>
+     *  <li> <code> getBounds() </code> : to have size of a component.</li>
+     * </ul>
+     */
+    public void _containsPoint() {
+        Rectangle bounds = oObj.getBounds();
+
+        boolean result = true;
+
+        int curX = 0;
+
+        while (!oObj.containsPoint(new Point(curX, 0)) &&
+               (curX < bounds.Width)) {
+            curX++;
+        }
+
+        if (curX < bounds.Width) {
+            log.println("Upper bound of box containsPoint point (" + curX +
+                        ",0) - OK");
+        } else {
+            log.println(
+                    "Upper bound of box containsPoint no component points - FAILED");
+            result = false;
+        }
+
+        curX = 0;
+
+        while (!oObj.containsPoint(new Point(curX, bounds.Height - 1)) &&
+               (curX < bounds.Width)) {
+            log.println("containsPoint returns false for (" + curX + "," +
+                        bounds.Height + ")");
+            curX++;
+        }
+
+        if (curX < bounds.Width) {
+            log.println("Lower bound of box containsPoint point (" + curX +
+                        "," + (bounds.Height - 1) + ") - OK");
+        } else {
+            log.println(
+                    "Lower bound of box containsPoint no component points - FAILED");
+            result = false;
+        }
+
+        int curY = 0;
+
+        while (!oObj.containsPoint(new Point(0, curY)) &&
+               (curY < bounds.Height)) {
+            curY++;
+        }
+
+        if (curY < bounds.Height) {
+            log.println("Left bound of box containsPoint point (0," + curY +
+                        ") - OK");
+        } else {
+            log.println(
+                    "Left bound of box containsPoint no component points - FAILED");
+            result = false;
+        }
+
+        curY = 0;
+
+        while (!oObj.containsPoint(new Point(bounds.Width - 1, curY)) &&
+               (curY < bounds.Height)) {
+            curY++;
+        }
+
+        if (curY < bounds.Height) {
+            log.println("Right bound of box containsPoint point (" +
+                        (bounds.Width - 1) + "," + curY + ") - OK");
+        } else {
+            log.println(
+                    "Right bound of box containsPoint no component points - FAILED");
+            result = false;
+        }
+
+        boolean locRes = true;
+
+        for (int x = -1; x <= bounds.Width; x++) {
+            if (oObj.containsPoint(new Point(x, -1))) {
+                log.println(
+                    "Outer upper and lower bounds CONTAIN some component point"
+                    + " (" + x + ", -1) - FAILED");
+                locRes = false;
+                break;
+            }
+            if (oObj.containsPoint(new Point(x, bounds.Height + bounds.Y))) {
+                log.println(
+                    "Outer upper and lower bounds CONTAIN some component point"
+                    + " (" + x + ", " + (bounds.Height + bounds.Y)
+                    + ") - FAILED");
+                locRes = false;
+                break;
+            }
+        }
+
+        if (locRes) {
+            log.println("Outer upper and lower bounds contain no component " +
+                        "points - OK");
+        } else {
+            result = false;
+        }
+
+        locRes = true;
+
+        for (int y = -1; y <= bounds.Height; y++) {
+            if (oObj.containsPoint(new Point(-1, y))) {
+                log.println(
+                    "Outer left and right bounds CONTAIN some component point"
+                    + " (-1, " + y + ") - FAILED");
+                locRes = false;
+                break;
+            }
+            if (oObj.containsPoint(new Point(bounds.X + bounds.Width, y))) {
+                log.println(
+                    "Outer left and right bounds CONTAIN some component point"
+                    + " (" + (bounds.X + bounds.Width) + ", " + y + ") - FAILED");
+                locRes = false;
+                break;
+            }
+        }
+
+        if (locRes) {
+            log.println("Outer left and right bounds contain no component " +
+                        "points - OK");
+        } else {
+            result = false;
+        }
+
+        tRes.tested("containsPoint()", result);
+    }
+
+    /**
+     * Iterates through all children which implement
+     * <code>XAccessibleComponent</code> (if they exist) determines their
+     * boundaries and tries to get each child by <code>getAccessibleAtPoint</code>
+     * passing point which belongs to the child.
+     * Also the point is checked which doesn't belong to child boundary
+     * box. <p>
+     *
+     * Has <b> OK </b> status if in the first cases the right children
+     * are returned, and in the second <code>null</code> or
+     * another child is returned.
+     */
+    public void _getAccessibleAtPoint() {
+        boolean result = true;
+        XAccessibleComponent[] children = getChildrenComponents();
+
+        if (children.length == 0) {
+            log.println("There are no children supporting XAccessibleComponent");
+            tRes.tested("getAccessibleAtPoint()", result);
+            return;
+        }
+
+        for (int i = 0; i < children.length; i++) {
+            Rectangle chBnd = children[i].getBounds();
+
+            if (chBnd.X == -1) {
+                continue;
+            }
+
+            log.println("Checking child with bounds " + "(" + chBnd.X +
+                        "," + chBnd.Y + "),(" + chBnd.Width + "," +
+                        chBnd.Height + "): " +
+                        util.AccessibilityTools.accessibleToString(
+                                children[i]));
+
+            XAccessibleContext xAc = UnoRuntime.queryInterface(
+                                             XAccessibleContext.class,
+                                             children[i]);
+
+            boolean MightBeCovered = false;
+            boolean isShowing = xAc.getAccessibleStateSet()
+                                   .contains(com.sun.star.accessibility.AccessibleStateType.SHOWING);
+            log.println("\tStateType containsPoint SHOWING: " +
+                        isShowing);
+
+            if (!isShowing) {
+                log.println("Child is invisible - OK");
+                continue;
+            }
+
+            log.println("finding the point which lies on the component");
+
+            int curX = chBnd.Width / 2;
+            int curY = chBnd.Height / 2;
+
+            while (!children[i].containsPoint(new Point(curX, curY)) &&
+                   (curX > 0) && (curY > 0)) {
+                curX--;
+                curY--;
+            }
+
+            if (curX == chBnd.Width) {
+                log.println("Couldn't find a point with containsPoint");
+
+                continue;
+            }
+
+            // trying the point laying on child
+            XAccessible xAcc = oObj.getAccessibleAtPoint(
+                                       new Point(chBnd.X + curX,
+                                                 chBnd.Y + curY));
+
+
+            Point p = new Point(chBnd.X + curX,chBnd.Y + curY);
+
+            if (isCovered(p)) {
+                log.println(
+                        "Child might be covered by another and can't be reached");
+                MightBeCovered = true;
+            }
+
+            KnownBounds.add(chBnd);
+
+            if (xAcc == null) {
+                log.println("The child not found at point (" +
+                            (chBnd.X + curX) + "," + (chBnd.Y + curY) +
+                            ") - FAILED");
+
+                 result = false;
+            } else {
+                XAccessible xAccCh = UnoRuntime.queryInterface(
+                                             XAccessible.class,
+                                             children[i]);
+                XAccessibleContext xAccC = UnoRuntime.queryInterface(
+                                                   XAccessibleContext.class,
+                                                   children[i]);
+                log.println("Child found at point (" + (chBnd.X + curX) +
+                            "," + (chBnd.Y + curY) + ") - OK");
+
+                boolean res = false;
+                int expIndex;
+                String expName;
+                String expDesc;
+
+                if (xAccCh != null) {
+                    res = util.AccessibilityTools.equals(xAccCh, xAcc);
+                    expIndex = xAccCh.getAccessibleContext()
+                                     .getAccessibleIndexInParent();
+                    expName = xAccCh.getAccessibleContext()
+                                    .getAccessibleName();
+                    expDesc = xAccCh.getAccessibleContext()
+                                    .getAccessibleDescription();
+                } else {
+                    res = xAccC.getAccessibleName()
+                               .equals(xAcc.getAccessibleContext()
+                                           .getAccessibleName());
+                    expIndex = xAccC.getAccessibleIndexInParent();
+                    expName = xAccC.getAccessibleName();
+                    expDesc = xAccC.getAccessibleDescription();
+                }
+
+                if (!res) {
+                    int gotIndex = xAcc.getAccessibleContext()
+                                       .getAccessibleIndexInParent();
+
+                    if (expIndex < gotIndex) {
+                        log.println("The children found is not the same");
+                        log.println("The expected child " + expName);
+                        log.print("is hidden behind the found Child ");
+                        log.println(xAcc.getAccessibleContext()
+                                        .getAccessibleName() + " - OK");
+                    } else {
+                        log.println(
+                                "The children found is not the same");
+                        log.println("Expected: " + expName);
+                        log.println("Description:  " + expDesc);
+                        log.println("Found: " +
+                                    xAcc.getAccessibleContext()
+                                        .getAccessibleName());
+                        log.println("Description:  " +
+                                    xAcc.getAccessibleContext()
+                                        .getAccessibleDescription());
+                        if (MightBeCovered) {
+                            log.println("... Child is covered by another - OK");
+                        } else {
+                            log.println("... FAILED");
+                            result = false;
+                        }
+
+                    }
+                }
+            }
+
+
+            // trying the point NOT laying on child
+            xAcc = oObj.getAccessibleAtPoint(
+                           new Point(chBnd.X - 1, chBnd.Y - 1));
+
+            if (xAcc == null) {
+                log.println("No children found at point (" +
+                            (chBnd.X - 1) + "," + (chBnd.Y - 1) +
+                            ") - OK");
+                result &= true;
+            } else {
+                XAccessible xAccCh = UnoRuntime.queryInterface(
+                                             XAccessible.class,
+                                             children[i]);
+                boolean res = util.AccessibilityTools.equals(xAccCh, xAcc);
+
+                if (res) {
+                    log.println("The same child found outside " +
+                                "its bounds at (" + (chBnd.X - 1) + "," +
+                                (chBnd.Y - 1) + ") - FAILED");
+                    result = false;
+                }
+            }
+        }
+
+        tRes.tested("getAccessibleAtPoint()", result);
+    }
+
+    /**
+     * Retrieves the component bounds and discards it. <p>
+     *
+     * Has <b> OK </b> status if boundary position (x,y) is not negative
+     * and size (Width, Height) is greater than 0.
+     */
+    public void _getBounds() {
+        boolean result = true;
+
+        Rectangle bounds = oObj.getBounds();
+        result &= ((bounds != null) && (bounds.X >= 0) && (bounds.Y >= 0) && (bounds.Width > 0) && (bounds.Height > 0));
+
+        log.println("Bounds = " +
+                    ((bounds != null)
+                     ? ("(" + bounds.X + "," + bounds.Y + "),(" +
+                               bounds.Width + "," + bounds.Height + ")") : "null"));
+
+        tRes.tested("getBounds()", result);
+    }
+
+    /**
+     * Gets the location. <p>
+     *
+     * Has <b> OK </b> status if the location is the same as location
+     * of boundary obtained by <code>getBounds()</code> method.
+     */
+    public void _getLocation() {
+        Rectangle bounds = oObj.getBounds();
+        Point loc = oObj.getLocation();
+        boolean result = loc.X == bounds.X && loc.Y == bounds.Y;
+        log.println(
+            "loc.X=" + loc.X + " vs. bounds.X=" + bounds.X + ", loc.Y="
+            + loc.Y + " vs. bounds.Y=" + bounds.Y);
+        tRes.tested("getLocation()", result);
+    }
+
+    /**
+     * Get the screen location of the component and its parent
+     * (if it exists and supports <code>XAccessibleComponent</code>). <p>
+     *
+     * Has <b> OK </b> status if component screen location equals
+     * to screen location of its parent plus location of the component
+     * relative to the parent. <p>
+     */
+    public void _getLocationOnScreen() {
+        XAccessibleComponent parent = getParentComponent();
+
+        boolean result = true;
+        Rectangle bounds = oObj.getBounds();
+        Point loc = oObj.getLocationOnScreen();
+        log.println("Location is (" + loc.X + "," + loc.Y + ")");
+
+        if (parent != null) {
+            Point parLoc = parent.getLocationOnScreen();
+            log.println("Parent location is (" + parLoc.X + "," + parLoc.Y +
+                        ")");
+
+            result &= ((parLoc.X + bounds.X) == loc.X);
+            result &= ((parLoc.Y + bounds.Y) == loc.Y);
+        }
+
+        tRes.tested("getLocationOnScreen()", result);
+    }
+
+    /**
+     * Obtains the size of the component. <p>
+     *
+     * Has <b> OK </b> status if the size is the same as in bounds. <p>
+     */
+    public void _getSize() {
+        requiredMethod("getBounds()");
+
+        boolean result = true;
+        Rectangle bounds = oObj.getBounds();
+        Size size = oObj.getSize();
+
+        result &= (size.Width == bounds.Width);
+        result &= (size.Height == bounds.Height);
+
+        tRes.tested("getSize()", result);
+    }
+
+    /**
+     * Just calls the method. <p>
+     *
+     * Has <b> OK </b> status if no runtime exceptions occurred.
+     */
+    public void _grabFocus() {
+        boolean result = true;
+        oObj.grabFocus();
+
+        tRes.tested("grabFocus()", result);
+    }
+
+    /**
+     * Retrieves all children (not more than 50) of the current
+     * component which support <code>XAccessibleComponent</code>.
+     *
+     * @return The array of children. Empty array returned if
+     * such children were not found or some error occurred.
+     */
+    private XAccessibleComponent[] getChildrenComponents() {
+        XAccessible xAcc = UnoRuntime.queryInterface(
+                                   XAccessible.class, oObj);
+
+        if (xAcc == null) {
+            log.println("Component doesn't support XAccessible.");
+
+            return new XAccessibleComponent[0];
+        }
+
+        XAccessibleContext xAccCon = xAcc.getAccessibleContext();
+        int cnt = xAccCon.getAccessibleChildCount();
+
+        // for cases when too many children exist checking only first 50
+        if (cnt > 50) {
+            cnt = 50;
+        }
+
+        ArrayList<XAccessibleComponent> childComp = new ArrayList<XAccessibleComponent>();
+
+        for (int i = 0; i < cnt; i++) {
+            try {
+                XAccessible child = xAccCon.getAccessibleChild(i);
+                XAccessibleContext xAccConCh = child.getAccessibleContext();
+                XAccessibleComponent xChAccComp = UnoRuntime.queryInterface(
+                                                          XAccessibleComponent.class,
+                                                          xAccConCh);
+
+                if (xChAccComp != null) {
+                    childComp.add(xChAccComp);
+                }
+            } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            }
+        }
+
+        return childComp.toArray(
+                         new XAccessibleComponent[childComp.size()]);
+    }
+
+    /**
+     * Gets the parent of the current component which support
+     * <code>XAccessibleComponent</code>.
+     *
+     * @return The parent or <code>null</code> if the component
+     * has no parent or some errors occurred.
+     */
+    private XAccessibleComponent getParentComponent() {
+        XAccessible xAcc = UnoRuntime.queryInterface(
+                                   XAccessible.class, oObj);
+
+        if (xAcc == null) {
+            log.println("Component doesn't support XAccessible.");
+
+            return null;
+        }
+
+        XAccessibleContext xAccCon = xAcc.getAccessibleContext();
+        XAccessible xAccPar = xAccCon.getAccessibleParent();
+
+        if (xAccPar == null) {
+            log.println("Component has no accessible parent.");
+
+            return null;
+        }
+
+        XAccessibleContext xAccConPar = xAccPar.getAccessibleContext();
+        XAccessibleComponent parent = UnoRuntime.queryInterface(
+                                              XAccessibleComponent.class,
+                                              xAccConPar);
+
+        if (parent == null) {
+            log.println(
+                    "Accessible parent doesn't support XAccessibleComponent");
+
+            return null;
+        }
+
+        return parent;
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getForeground() {
+        int forColor = oObj.getForeground();
+        log.println("getForeground(): " + forColor);
+        tRes.tested("getForeground()", true);
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getBackground() {
+        int backColor = oObj.getBackground();
+        log.println("getBackground(): " + backColor);
+        tRes.tested("getBackground()", true);
+    }
+
+    /**
+     * Restores initial component text.
+     */
+    @Override
+    protected void after() {
+        if (tEnv.getObjRelation("Destroy") != null) {
+            disposeEnvironment();
+        }
+    }
+
+    private boolean isCovered(Point p) {
+        int elements = KnownBounds.size();
+        boolean Covered = false;
+        for (int k=0;k<elements;k++) {
+            Rectangle known = KnownBounds.get(k);
+            Covered = (known.X < p.X);
+            Covered &= (known.Y < p.Y);
+            Covered &= (p.Y < known.Y+known.Height);
+            Covered &= (p.X < known.X+known.Width);
+
+            if (Covered) {
+                break;
+            }
+        }
+        return Covered;
+    }
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleContext.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleContext.java
new file mode 100644
index 000000000..cabf818af
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleContext.java
@@ -0,0 +1,342 @@
+/*
+ * 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.IllegalAccessibleComponentStateException;
+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleContext;
+import com.sun.star.accessibility.XAccessibleStateSet;
+import com.sun.star.lang.Locale;
+
+import lib.MultiMethodTest;
+
+import util.AccessibilityTools;
+
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleContext</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> getAccessibleChildCount()</code></li>
+ *  <li><code> getAccessibleChild()</code></li>
+ *  <li><code> getAccessibleParent()</code></li>
+ *  <li><code> getAccessibleIndexInParent()</code></li>
+ *  <li><code> getAccessibleRole()</code></li>
+ *  <li><code> getAccessibleDescription()</code></li>
+ *  <li><code> getAccessibleName()</code></li>
+ *  <li><code> getAccessibleRelationSet()</code></li>
+ *  <li><code> getAccessibleStateSet()</code></li>
+ *  <li><code> getLocale()</code></li>
+ * </ul> <p>
+ *
+ * @see com.sun.star.accessibility.XAccessibleContext
+ */
+public class _XAccessibleContext extends MultiMethodTest {
+    private static final String className = "com.sun.star.accessibility.XAccessibleContext";
+    public XAccessibleContext oObj = null;
+    private int childCount = 0;
+    private XAccessible parent = null;
+
+    // temporary while accessibility package is in com.sun.star
+    @Override
+    protected String getTestedClassName() {
+        return className;
+    }
+
+    /**
+     * Calls the method and stores the number of children. <p>
+     * Has <b> OK </b> status if non-negative number rutrned.
+     */
+    public void _getAccessibleChildCount() {
+        childCount = oObj.getAccessibleChildCount();
+        log.println(childCount + " children found.");
+        tRes.tested("getAccessibleChildCount()", childCount > -1);
+    }
+
+    /**
+     * Tries to get every child and checks its parent. <p>
+     *
+     * Has <b> OK </b> status if parent of every child
+     * and the tested component are the same objects.
+     *
+     * The following method tests are to be completed successfully before :
+     * <ul>
+     *  <li> <code> getAccessibleChildCount() </code> : to have a number of
+     *     children </li>
+     * </ul>
+     */
+    public void _getAccessibleChild() {
+        requiredMethod("getAccessibleChildCount()");
+
+        log.println("testing 'getAccessibleChild()'...");
+
+        boolean bOK = true;
+        int counter = childCount;
+
+        if (childCount > 500) {
+            counter = 500;
+        }
+
+        for (int i = 0; i < counter; i++) {
+            try {
+                XAccessible ch = oObj.getAccessibleChild(i);
+                XAccessibleContext chAC = ch.getAccessibleContext();
+
+                log.println("## Child " + i + ": " +
+                            chAC.getAccessibleDescription());
+
+                if (!AccessibilityTools.equals(chAC.getAccessibleParent()
+                                                   .getAccessibleContext(),
+                                               oObj)) {
+                    log.println("The parent of child and component " +
+                                "itself differ.");
+                    log.println("\tRole:");
+                    log.println("Getting:  " +
+                                chAC.getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleRole());
+                    log.println("Expected: " + oObj.getAccessibleRole());
+
+                    log.println("\tImplementationName:");
+                    log.println("Getting:  " +
+                                util.utils.getImplName(
+                                        chAC.getAccessibleParent()
+                                            .getAccessibleContext()));
+                    log.println("Expected: " + util.utils.getImplName(oObj));
+
+                    log.println("\tAccessibleDescription:");
+                    log.println("Getting(Description):  " +
+                                chAC.getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleDescription());
+                    log.println("Expected(Description): " +
+                                oObj.getAccessibleDescription());
+
+                    log.println("\tAccessibleName:");
+                    log.println("Getting(Name):  " +
+                                chAC.getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleName());
+                    log.println("Expected(Name): " +
+                                oObj.getAccessibleName());
+
+                    log.println("\tChildCount:");
+                    log.println("Getting:  " +
+                                chAC.getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleChildCount());
+                    log.println("Expected: " +
+                                oObj.getAccessibleChildCount());
+
+                    log.println("\tParentName:");
+                    log.println("Getting (Name):  " +
+                                chAC.getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleName());
+                    log.println("Expected(Name): " +
+                                oObj.getAccessibleParent()
+                                    .getAccessibleContext()
+                                    .getAccessibleName());
+
+                    log.println("##");
+                    bOK = false;
+                } else {
+                    log.println("Role: " + chAC.getAccessibleRole());
+                    log.println("Name: " + chAC.getAccessibleName());
+                    log.println("IndexInParent: " +
+                                chAC.getAccessibleIndexInParent());
+                    log.println("ImplementationName: " +
+                                util.utils.getImplName(chAC));
+                }
+            } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+                e.printStackTrace(log);
+                bOK = false;
+            }
+        }
+
+        tRes.tested("getAccessibleChild()", bOK);
+    }
+
+    /**
+     * Just gets the parent. <p>
+     *
+     * Has <b> OK </b> status if parent is not null.
+     */
+    public void _getAccessibleParent() {
+        // assume that the component is not ROOT
+        parent = oObj.getAccessibleParent();
+        tRes.tested("getAccessibleParent()", parent != null);
+    }
+
+    /**
+     * Retrieves the index of tested component in its parent.
+     * Then gets the parent's child by this index and compares
+     * it with tested component.<p>
+     *
+     * Has <b> OK </b> status if the parent's child and the tested
+     * component are the same objects.
+     *
+     * The following method tests are to be completed successfully before :
+     * <ul>
+     *  <li> <code> getAccessibleParent() </code> : to have a parent </li>
+     * </ul>
+     */
+    public void _getAccessibleIndexInParent() {
+        requiredMethod("getAccessibleParent()");
+
+        boolean bOK = true;
+        int idx = oObj.getAccessibleIndexInParent();
+
+        XAccessibleContext parentAC = parent.getAccessibleContext();
+
+        try {
+            XAccessible child = parentAC.getAccessibleChild(idx);
+            XAccessibleContext childAC = null;
+            if (child == null) {
+                log.println("Parent has no child with this index");
+                bOK &= false;
+            } else {
+                childAC = child.getAccessibleContext();
+                bOK &= AccessibilityTools.equals(childAC, oObj);
+            }
+
+            if (!bOK) {
+                log.println("Expected: " + util.utils.getImplName(oObj));
+
+                if (childAC != null) {
+                    log.println("Getting: " + util.utils.getImplName(childAC));
+                }
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            e.printStackTrace(log);
+            bOK = false;
+        }
+
+        tRes.tested("getAccessibleIndexInParent()", bOK);
+    }
+
+    /**
+     * Get the accessible role of component. <p>
+     *
+     * Has <b> OK </b> status if non-negative number rutrned.
+     */
+    public void _getAccessibleRole() {
+        short role = oObj.getAccessibleRole();
+        log.println("The role is " + role);
+        tRes.tested("getAccessibleRole()", role > -1);
+    }
+
+    /**
+     * Get the accessible name of the component. <p>
+     *
+     * Has <b> OK </b> status if the name has non-zero length.
+     */
+    public void _getAccessibleName() {
+        String name = oObj.getAccessibleName();
+        log.println("The name is '" + name + "'");
+        tRes.tested("getAccessibleName()", name != null);
+    }
+
+    /**
+     * Get the accessible description of the component. <p>
+     *
+     * Has <b> OK </b> status if the description has non-zero length.
+     */
+    public void _getAccessibleDescription() {
+        String descr = oObj.getAccessibleDescription();
+        log.println("The description is '" + descr + "'");
+        tRes.tested("getAccessibleDescription()", descr != null);
+    }
+
+    /**
+     * Just gets the set. <p>
+     *
+     * Has <b> OK </b> status if the set is not null.
+     */
+    public void _getAccessibleRelationSet() {
+        oObj.getAccessibleRelationSet();
+        tRes.tested("getAccessibleRelationSet()", true);
+    }
+
+    /**
+     * Just gets the set. <p>
+     *
+     * Has <b> OK </b> status if the set is not null.
+     */
+    public void _getAccessibleStateSet() {
+        XAccessibleStateSet set = oObj.getAccessibleStateSet();
+        boolean res = true;
+        String[] expectedStateNames = (String[]) tEnv.getObjRelation(
+                                                "expectedStateNames");
+        short[] expectedStates = (short[]) tEnv.getObjRelation(
+                                           "expectedStates");
+
+        if ((expectedStateNames != null) && (expectedStates != null)) {
+            res = checkStates(expectedStateNames, expectedStates, set);
+        } else {
+            res = set != null;
+        }
+
+        tRes.tested("getAccessibleStateSet()", res);
+    }
+
+    /**
+     * Gets the locale. <p>
+     *
+     * Has <b> OK </b> status if <code>Country</code> and
+     * <code>Language</code> fields of locale structure
+     * are not empty.
+     */
+    public void _getLocale() {
+        Locale loc = null;
+
+        try {
+            loc = oObj.getLocale();
+            log.println("The locale is " + loc.Language + "," + loc.Country);
+        } catch (IllegalAccessibleComponentStateException e) {
+            e.printStackTrace(log);
+        }
+
+        tRes.tested("getLocale()",
+                    (loc != null) && (loc.Language.length() > 0));
+    }
+
+    protected boolean checkStates(String[] expectedStateNames,
+                                  short[] expectedStates,
+                                  XAccessibleStateSet set) {
+        boolean works = true;
+
+        for (int k = 0; k < expectedStateNames.length; k++) {
+            boolean contains = set.contains(expectedStates[k]);
+
+            if (contains) {
+                log.println("Set contains " + expectedStateNames[k] +
+                            " ... OK");
+                works &= true;
+            } else {
+                log.println("Set doesn't contain " + expectedStateNames[k] +
+                            " ... FAILED");
+                works &= false;
+            }
+        }
+
+        return works;
+    }
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleEditableText.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleEditableText.java
new file mode 100644
index 000000000..d8cb81adc
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleEditableText.java
@@ -0,0 +1,543 @@
+/*
+ * 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 lib.MultiMethodTest;
+import util.ValueComparer;
+
+import com.sun.star.accessibility.XAccessibleEditableText;
+import com.sun.star.beans.PropertyValue;
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleEditableText</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> cutText()</code></li>
+ *  <li><code> pasteText()</code></li>
+ *  <li><code> deleteText()</code></li>
+ *  <li><code> insertText()</code></li>
+ *  <li><code> replaceText()</code></li>
+ *  <li><code> setAttributes()</code></li>
+ *  <li><code> setText()</code></li>
+ * </ul> <p>
+ *
+ * This test needs the following object relations :
+ * <ul>
+ *  <li> <code>'XAccessibleEditableText.hasAttr'</code>
+ *  (of type <code>Boolean</code>):
+ *   Indicates whether or not the text has changeable attributes.
+ *   E.g. text within writer document have attributes which can
+ *   be changed, while the text within edit field has fixed
+ *   attributes. <p>
+ *   If the relation is <code>false</code> then the component
+ *   has fixed text attributes. </li>
+ * </ul> <p>
+ *
+ * @see com.sun.star.accessibility.XAccessibleEditableText
+ */
+public class _XAccessibleEditableText extends MultiMethodTest {
+
+    public XAccessibleEditableText oObj = null;
+
+
+    String pasteText = null;
+
+    String initialText = "";
+
+    /**
+     * Indicates whether or not the text has changeable attributes.
+     * E.g. text within writer document have attributes which can
+     * be changed, while the text within edit field has fixed
+     * attributes.
+     */
+     private boolean changeableAttr = true;
+
+     /**
+      * Retrieves object relation. Stores initial component text
+      * for restoring it in <code>after</code>.
+      */
+     @Override
+    protected void before() {
+        Boolean b = (Boolean)
+            tEnv.getObjRelation("XAccessibleEditableText.hasAttr");
+        if (b != null) {
+            changeableAttr = b.booleanValue();
+        }
+
+        initialText = oObj.getText();
+     }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct indexes.
+     * Stores cutted text in the variable <code>pasteText</code>.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct indexes.
+     */
+    public void _cutText() {
+        boolean res = true;
+        boolean locRes = true;
+        String curText = null;
+
+        String oldText = oObj.getText();
+        log.println("Text: '" + oldText + "'");
+        int length = oObj.getCharacterCount();
+        log.println("Character count: " + length);
+
+        try {
+            log.print("cutText(-1," + (length-1) + "): ");
+            locRes = oObj.cutText(-1, length - 1);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(oldText);
+        }
+
+        try {
+            log.print("cutText(0," + (length+1) + "): ");
+            locRes = oObj.cutText(0, length + 1);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(oldText);
+        }
+
+        try {
+            pasteText = oldText;
+            log.print("cutText(0," + length + "): ");
+            locRes = oObj.cutText(0, length);
+            log.println(locRes);
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.length() == 0 && locRes;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("cutText()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct indexes.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct indexes and if cutted text was
+     * pasted.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>cutText()</code> </li>
+     * </ul>
+     */
+    public void _pasteText() {
+        requiredMethod("cutText()");
+        boolean res = true;
+        boolean locRes = true;
+        String curText = null;
+
+        String text = oObj.getText();
+        log.println("Text: '" + text + "'");
+        int length = oObj.getCharacterCount();
+        log.println("Character count: " + length);
+
+        try {
+            log.print("pasteText(-1): ");
+            locRes = oObj.pasteText(-1);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("pasteText(" + (length+1) + "): ");
+            locRes = oObj.pasteText(length + 1);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("pasteText(" + (length) + "): ");
+            locRes = oObj.pasteText(length);
+            log.println(locRes);
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text + pasteText) && locRes;
+            log.println("Expected text: '" + text + pasteText + "'");
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("pasteText()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct indexes,
+     * checks text after method call.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct indexes and if deleted string
+     * was really deleted from the text.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>insertText()</code> </li>
+     * </ul>
+     */
+    public void _deleteText() {
+        executeMethod("insertText()");
+        boolean res = true;
+        boolean locRes = true;
+        String curText = null;
+
+        String text = oObj.getText();
+        log.println("Text: '" + text + "'");
+        int length = oObj.getCharacterCount();
+        log.println("Character count: " + length);
+
+        try {
+            log.print("deleteText(-1," + length + "): ");
+            locRes = oObj.deleteText(-1, length);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("deleteText(0," + (length+1) + "): ");
+            locRes = oObj.deleteText(0, length + 1);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            if (length >= 1) {
+                log.print("deleteText(" + (length-1) + "," + (length) + "): ");
+                locRes = oObj.deleteText(length - 1, length);
+                log.println(locRes);
+                String expStr = text.substring(0, length - 1);
+                curText = oObj.getText();
+                log.println("Current text: '" + curText + "'");
+                res &= curText.equals(expStr);
+                log.println("Expected text: '" + expStr + "'");
+            }
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("deleteText()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct indexes,
+     * checks text after method call.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct indexes and if inserted string
+     * was really inserted into the text.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>pasteText()</code> </li>
+     * </ul>
+     */
+    public void _insertText() {
+        executeMethod("pasteText()");
+        boolean res = true;
+        boolean locRes = true;
+        String curText = null;
+
+        String text = oObj.getText();
+        log.println("Text: '" + text + "'");
+        int length = oObj.getCharacterCount();
+        log.println("Character count: " + length);
+
+        final String insStr = "Inserted string";
+
+        try {
+            log.print("insertText(insStr, -1): ");
+            locRes = oObj.insertText(insStr, -1);
+            log.println(locRes);
+            log.println("exception was expected=> FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("insertText(insStr," + (length+1) + "): ");
+            locRes = oObj.insertText(insStr, length+1);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("insertText(insStr," + length + "): ");
+            locRes = oObj.insertText(insStr, length);
+            log.println(locRes);
+            curText = oObj.getText();
+            res &= curText.equals(text + insStr);
+            log.println("Current text: '" + curText + "'");
+            log.println("Expected text: '" + text + insStr + "'");
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("insertText()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct indexes,
+     * checks text after method call.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct indexes and if part of text
+     * was really replaced by the specified replacement string.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>deleteText()</code> </li>
+     * </ul>
+     */
+    public void _replaceText() {
+        executeMethod("deleteText()");
+        boolean res = true;
+        boolean locRes = true;
+        String curText = null;
+
+        final String sReplacement = "String for replace";
+        String oldText = oObj.getText();
+        int startIndx = oldText.length();
+        oObj.setText(oldText + " part of string for replace");
+
+        String text = oObj.getText();
+        log.println("Text: '" + text + "'");
+        int length = oObj.getCharacterCount();
+        log.println("Character count: " + length);
+
+        try {
+            log.print("replaceText(-1," + length + "): ");
+            locRes = oObj.replaceText(-1, length, sReplacement);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("replaceText(0," + (length+1) + "): ");
+            locRes = oObj.replaceText(0, length + 1, sReplacement);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            res &= curText.equals(text);
+        }
+
+        try {
+            log.print("replaceText(" + startIndx + "," + length + "): ");
+            locRes = oObj.replaceText(startIndx, length, sReplacement);
+            log.println(locRes);
+            curText = oObj.getText();
+            log.println("Current text: '" + curText + "'");
+            log.println("Expected text: '" + oldText + sReplacement + "'");
+            res &= curText.equals(oldText + sReplacement);
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("replaceText()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct indexes,
+     * checks attributes after method call.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct indexes and if attributes
+     * of text was changed.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>replaceText()</code> </li>
+     * </ul>
+     */
+    public void _setAttributes() {
+        executeMethod("replaceText()");
+        boolean res = true;
+        boolean locRes = true;
+
+        String text = oObj.getText();
+        log.println("Text: '" + text + "'");
+        int length = oObj.getCharacterCount();
+        log.println("Length: " + length);
+
+        PropertyValue[] attrs = null;
+
+        try {
+            attrs = oObj.getCharacterAttributes(0, new String[]{""});
+            log.print("setAttributes(-1," + (length - 1) + "):");
+            locRes = oObj.setAttributes(-1, length - 1, attrs);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            res &= true;
+        } catch(com.sun.star.beans.UnknownPropertyException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        try {
+            log.print("setAttributes(0," + (length+1) + "):");
+            locRes = oObj.setAttributes(0, length + 1, attrs);
+            log.println(locRes);
+            log.println("exception was expected => FAILED");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception => OK");
+            res &= true;
+        }
+
+        //change old attributes set
+        for(int i = 0; i < attrs.length; i++) {
+            if (attrs[i].Name.equals("CharColor")) {
+                attrs[i].Value = Integer.valueOf(-2);
+            }
+        }
+
+        try {
+            log.print("setAttributes(0," + length + "):");
+            locRes = oObj.setAttributes(0, length, attrs);
+            log.println(locRes);
+            res &= (changeableAttr && locRes)
+                || (!changeableAttr && !locRes);
+            if (changeableAttr) {
+                log.print("checking that new attributes was set...");
+                PropertyValue[] newAttrs = oObj.getCharacterAttributes(0, new String[]{""});
+                locRes = ValueComparer.equalValue(attrs, newAttrs);
+                log.println(locRes);
+                res &= locRes;
+            } else {
+                log.println("Text attributes can't be changed.");
+            }
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        } catch(com.sun.star.beans.UnknownPropertyException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("setAttributes()", res);
+    }
+
+    /**
+     * Calls the method with different parameters and checks text.
+     */
+    public void _setText() {
+        executeMethod("setAttributes()");
+        boolean res = true;
+        boolean locRes = true;
+
+        String oldText = oObj.getText();
+        log.println("Current text: '" + oldText + "'");
+
+        String newText = "New text";
+        log.print("setText('" + newText + "'): ");
+        locRes = oObj.setText(newText);
+        log.println(locRes);
+        String newCurText = oObj.getText();
+        log.println("getText(): '" + newCurText + "'");
+        res &= locRes && newCurText.equals(newText);
+
+        newText = "";
+        log.print("setText('" + newText + "'): ");
+        locRes = oObj.setText(newText);
+        log.println(locRes);
+        newCurText = oObj.getText();
+        log.println("getText(): '" + newCurText + "'");
+        res &= locRes && newCurText.equals(newText);
+
+        log.print("setText('" + oldText + "'): ");
+        locRes = oObj.setText(oldText);
+        log.println(locRes);
+        newCurText = oObj.getText();
+        log.println("getText(): '" + newCurText + "'");
+        res &= locRes && newCurText.equals(oldText);
+
+        tRes.tested("setText()", res);
+    }
+
+    /**
+     * Restores initial component text.
+     */
+    @Override
+    protected void after() {
+        oObj.setText(initialText);
+    }
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleEventBroadcaster.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleEventBroadcaster.java
new file mode 100644
index 000000000..297166988
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleEventBroadcaster.java
@@ -0,0 +1,208 @@
+/*
+ * 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 lib.MultiMethodTest;
+import lib.Status;
+import lib.StatusException;
+
+import com.sun.star.accessibility.AccessibleEventObject;
+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleContext;
+import com.sun.star.accessibility.XAccessibleEventBroadcaster;
+import com.sun.star.accessibility.XAccessibleEventListener;
+import com.sun.star.lang.EventObject;
+import com.sun.star.uno.UnoRuntime;
+
+/**
+ * Testing <code>
+ * com.sun.star.accessibility.XAccessibleEventBroadcaster</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> addAccessibleEventListener()</code></li>
+ *  <li><code> removeAccessibleEventListener()</code></li>
+ * </ul> <p>
+ *
+ * This test needs the following object relations :
+ * <ul>
+ *  <li> <code>'EventProducer'</code> (of type
+ *  <code>ifc.accessibility._XAccessibleEventBroadcaster.EventProducer</code>):
+ *   this must be an implementation of the interface which could perform
+ *   some actions for generating any kind of <code>AccessibleEvent</code></li>
+ * <ul> <p>
+ *
+ * @see com.sun.star.accessibility.XAccessibleEventBroadcaster
+ */
+public class _XAccessibleEventBroadcaster extends MultiMethodTest {
+
+    public interface EventProducer {
+        void fireEvent();
+    }
+
+    public XAccessibleEventBroadcaster oObj = null;
+    public String EventMsg = "";
+    public boolean destroy = false;
+
+
+    /**
+     * Listener implementation which registers listener calls.
+     */
+    private class EvListener implements XAccessibleEventListener {
+        public AccessibleEventObject notifiedEvent = null ;
+        public void notifyEvent(AccessibleEventObject ev) {
+            log.println("Listener, Event : " + ev.EventId);
+            System.out.println("EventID: " + ev.EventId);
+            Object old=ev.OldValue;
+            if (old instanceof com.sun.star.accessibility.XAccessible) {
+                System.out.println("Old: "+((XAccessible)old).getAccessibleContext().getAccessibleName());
+            }
+
+            Object nev=ev.NewValue;
+            if (nev instanceof com.sun.star.accessibility.XAccessible) {
+                System.out.println("New: "+((XAccessible)nev).getAccessibleContext().getAccessibleName());
+            }
+            synchronized (this) {
+                notifiedEvent = ev;
+            }
+        }
+
+        public void disposing(EventObject ev) {}
+    }
+
+    /**
+     * Retrieves relation.
+     * @throws StatusException If the relation is not found.
+     */
+    @Override
+    public void before() {
+        prod = (EventProducer) tEnv.getObjRelation("EventProducer") ;
+        if (prod == null) {
+            throw new StatusException(Status.failed("Relation missed."));
+        }
+        EventMsg = (String) tEnv.getObjRelation("EventMsg");
+        Object dp = tEnv.getObjRelation("Destroy");
+        if (dp != null) {
+            destroy=true;
+        }
+    }
+
+    EventProducer prod = null ;
+    EvListener list = new EvListener();
+
+    /**
+     * Adds two listeners and fires event by mean of object relation. <p>
+     * Has <b> OK </b> status if both listeners were called
+     */
+    public void _addEventListener() {
+        log.println("adding listener");
+        oObj.addAccessibleEventListener(list);
+        boolean isTransient = chkTransient(tEnv.getTestObject());
+        log.println("fire event");
+        prod.fireEvent() ;
+
+        waitForEventIdle();
+
+        boolean works = true;
+
+        AccessibleEventObject ne;
+        synchronized (list) {
+            ne = list.notifiedEvent;
+        }
+        if (ne == null) {
+            if (!isTransient) {
+                log.println("listener wasn't called");
+                works = false;
+            } else {
+                log.println("Object is Transient, listener isn't expected to be called");
+            }
+            oObj.removeAccessibleEventListener(list);
+        }
+
+        if (EventMsg != null) {
+            log.println(EventMsg);
+            tRes.tested("addEventListener()", Status.skipped(true) );
+            return;
+        }
+
+        tRes.tested("addEventListener()", works );
+    }
+
+    /**
+     * Removes one of two listeners added before and fires event
+     * by mean of object relation.<p>
+     *
+     * Has <b> OK </b> status if the removed listener wasn't called.<p>
+     *
+     * The following method tests are to be completed successfully before:
+     * <ul>
+     *  <li> <code>addEventListener()</code> : to have added listeners </li>
+     * </ul>
+     */
+    public void _removeEventListener() throws Exception {
+        requiredMethod("addEventListener()");
+
+        log.println("remove listener");
+        oObj.removeAccessibleEventListener(list);
+
+        synchronized (list) {
+            list.notifiedEvent = null;
+        }
+
+        log.println("fire event");
+        prod.fireEvent() ;
+
+        waitForEventIdle();
+
+        AccessibleEventObject ne;
+        synchronized (list) {
+            ne = list.notifiedEvent;
+        }
+        if (ne == null) {
+            log.println("listener wasn't called -- OK");
+        }
+
+        tRes.tested("removeEventListener()", list.notifiedEvent == null);
+
+    }
+
+    protected static boolean chkTransient(Object Testcase) {
+        boolean ret = false;
+        XAccessibleContext accCon = UnoRuntime.queryInterface(XAccessibleContext.class,Testcase);
+        if (accCon.getAccessibleStateSet().contains(
+            com.sun.star.accessibility.AccessibleStateType.TRANSIENT)){
+            if (!accCon.getAccessibleParent().getAccessibleContext().getAccessibleStateSet().contains(
+                com.sun.star.accessibility.AccessibleStateType.MANAGES_DESCENDANTS)) {
+                throw new lib.StatusException(lib.Status.failed("Parent doesn't manage descendents"));
+            }
+            ret=true;
+        }
+        return ret;
+    }
+
+    /**
+    * Forces environment recreation.
+    */
+    @Override
+    protected void after() {
+        if (destroy) disposeEnvironment();
+    }
+
+
+}
+
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleExtendedComponent.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleExtendedComponent.java
new file mode 100644
index 000000000..0b2c204c2
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleExtendedComponent.java
@@ -0,0 +1,114 @@
+/*
+ * 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 lib.MultiMethodTest;
+
+import com.sun.star.accessibility.XAccessibleExtendedComponent;
+import com.sun.star.awt.XFont;
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleExtendedComponent</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> getForeground()</code></li>
+ *  <li><code> getBackground()</code></li>
+ *  <li><code> getFont()</code></li>
+ *  <li><code> isEnabled()</code></li>
+ *  <li><code> getTitledBorderText()</code></li>
+ *  <li><code> getToolTipText()</code></li>
+ * </ul> <p>
+ * @see com.sun.star.accessibility.XAccessibleExtendedComponent
+ */
+public class _XAccessibleExtendedComponent extends MultiMethodTest {
+
+    public XAccessibleExtendedComponent oObj = null;
+
+    /**
+     * Just calls the method.
+     * deprecated from version srx644g 29.10.02 on
+     *
+    public void _getForeground() {
+        int forColor = oObj.getForeground();
+        log.println("getForeground(): " + forColor);
+        tRes.tested("getForeground()", true);
+    }
+
+    /**
+     * Just calls the method.
+     * deprecated from version srx644g 29.10.02 on
+     *
+    public void _getBackground() {
+        int backColor = oObj.getBackground();
+        log.println("getBackground(): " + backColor);
+        tRes.tested("getBackground()", true);
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getFont() {
+        XFont font = oObj.getFont();
+        log.println("getFont(): " + font);
+        tRes.tested("getFont()", true);
+    }
+
+    /**
+     * Calls the method and compares returned value with value that was
+     * returned by the method
+     * <code>XAccessibleStateSet.contains(AccessibleStateType.ENABLED)</code>.
+     * Has OK status if returned values are equal.
+     * deprecated from version srx644g 29.10.02 on
+     *
+    public void _isEnabled() {
+        boolean isEnabled = oObj.isEnabled();
+        log.println("isEnabled(): " + isEnabled);
+
+        boolean res = true;
+
+        XAccessibleStateSet accStateSet = (XAccessibleStateSet)
+            UnoRuntime.queryInterface(XAccessibleStateSet.class, oObj);
+
+        if (accStateSet != null) {
+            res = accStateSet.contains(AccessibleStateType.ENABLED)==isEnabled;
+        }
+
+        tRes.tested("isEnabled()", res);
+    }
+
+    /**
+     * Calls the method and checks returned value.
+     * Has OK status if returned value isn't null.
+     */
+    public void _getTitledBorderText() {
+        String titleBorderText = oObj.getTitledBorderText();
+        log.println("getTitledBorderText(): '" + titleBorderText + "'");
+        tRes.tested("getTitledBorderText()", titleBorderText != null);
+    }
+
+    /**
+     * Calls the method and checks returned value.
+     * Has OK status if returned value isn't null.
+     */
+    public void _getToolTipText() {
+        String toolTipText = oObj.getToolTipText();
+        log.println("getToolTipText(): '" + toolTipText + "'");
+        tRes.tested("getToolTipText()", toolTipText != null);
+    }
+}
\ No newline at end of file
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleImage.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleImage.java
new file mode 100644
index 000000000..c19b06850
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleImage.java
@@ -0,0 +1,65 @@
+/*
+ * 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 lib.MultiMethodTest;
+
+import com.sun.star.accessibility.XAccessibleImage;
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleImage</code>
+ * interface methods :
+ * <ul>
+ *  <li><code>getAccessibleImageDescription()</code></li>
+ *  <li><code>getAccessibleImageHeight()</code></li>
+ *  <li><code>getAccessibleImageWidth()</code></li>
+ * </ul> <p>
+ * @see com.sun.star.accessibility.XAccessibleImage
+ */
+public class _XAccessibleImage extends MultiMethodTest {
+
+    public XAccessibleImage oObj = null;
+
+    /**
+     * Just calls the method.
+     */
+    public void _getAccessibleImageDescription() {
+        String descr = oObj.getAccessibleImageDescription();
+        log.println("getAccessibleImageDescription(): '" + descr + "'");
+        tRes.tested("getAccessibleImageDescription()", descr != null);
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getAccessibleImageHeight() {
+        int height = oObj.getAccessibleImageHeight();
+        log.println("getAccessibleImageHeight(): " + height);
+        tRes.tested("getAccessibleImageHeight()", true);
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getAccessibleImageWidth() {
+        int width = oObj.getAccessibleImageWidth();
+        log.println("getAccessibleImageWidth(): " + width);
+        tRes.tested("getAccessibleImageWidth()", true);
+    }
+}
\ No newline at end of file
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 <code>com.sun.star.accessibility.XAccessibleSelection</code>
+ * interface methods :
+ * <ul>
+ *  <li><code>selectAccessibleChild()</code></li>
+ *  <li><code>isAccessibleChildSelected()</code></li>
+ *  <li><code>clearAccessibleSelection()</code></li>
+ *  <li><code>selectAllAccessibleChildren()</code></li>
+ *  <li><code>getSelectedAccessibleChildCount()</code></li>
+ *  <li><code>getSelectedAccessibleChild()</code></li>
+ *  <li><code>deselectAccessibleChild()</code></li>
+ * </ul> <p>
+ *
+ * This test needs the following object relations :
+ * <ul>
+ *  <li> <code>'XAccessibleSelection.multiSelection'</code>
+ *  (of type <code>Boolean</code>) <b> optional </b>:
+ *   Indicates whether or not multiply children could be selected.
+ *   If the relation is <code>false</code> then more than 1 child
+ *   couldn't be selected. </li>
+ * </ul> <p>
+ *
+ * @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 <code>XAccessibleContext</code>
+     * 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 <code>isAccessibleChildSelected()</code>
+     * returned <code>false</code>.
+     */
+    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 <code>isAccessibleChildSelected()</code>
+     * returns <code>true</code> 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.
+     * <p>
+     * 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;
+    }
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleTable.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleTable.java
new file mode 100644
index 000000000..ee2400f44
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleTable.java
@@ -0,0 +1,1000 @@
+/*
+ * 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 lib.MultiMethodTest;
+
+import com.sun.star.accessibility.XAccessible;
+import com.sun.star.accessibility.XAccessibleContext;
+import com.sun.star.accessibility.XAccessibleSelection;
+import com.sun.star.accessibility.XAccessibleTable;
+import com.sun.star.uno.UnoRuntime;
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleTable</code>
+ * interface methods :
+ * <ul>
+ *  <li><code>getAccessibleRowCount()</code></li>
+ *  <li><code>getAccessibleColumnCount()</code></li>
+ *  <li><code>getAccessibleRowDescription()</code></li>
+ *  <li><code>getAccessibleColumnDescription()</code></li>
+ *  <li><code>getAccessibleRowExtentAt()</code></li>
+ *  <li><code>getAccessibleColumnExtentAt()</code></li>
+ *  <li><code>getAccessibleRowHeaders()</code></li>
+ *  <li><code>getAccessibleColumnHeaders()</code></li>
+ *  <li><code>getSelectedAccessibleRows()</code></li>
+ *  <li><code>getSelectedAccessibleColumns()</code></li>
+ *  <li><code>isAccessibleRowSelected()</code></li>
+ *  <li><code>isAccessibleColumnSelected()</code></li>
+ *  <li><code>getAccessibleCellAt()</code></li>
+ *  <li><code>getAccessibleCaption()</code></li>
+ *  <li><code>getAccessibleSummary()</code></li>
+ *  <li><code>isAccessibleSelected()</code></li>
+ *  <li><code>getAccessibleIndex()</code></li>
+ *  <li><code>getAccessibleRow()</code></li>
+ *  <li><code>getAccessibleColumn()</code></li>
+ * </ul> <p>
+ * @see com.sun.star.accessibility.XAccessibleTable
+ */
+public class _XAccessibleTable extends MultiMethodTest {
+
+    public XAccessibleTable oObj = null;
+    XAccessibleSelection xASel = null;
+    XAccessibleContext xACont = null;
+
+    @Override
+    protected void before() {
+        xASel = UnoRuntime.queryInterface(XAccessibleSelection.class, oObj);
+        if (xASel == null) {
+            log.println("The component doesn't implement the interface " +
+                "XAccessibleSelection.");
+            log.println("This interface is required for more detailed tests.");
+        }
+
+        xACont = UnoRuntime.queryInterface(XAccessibleContext.class, oObj);
+    }
+
+    int rowCount = 0;
+
+    /**
+     * Calls the method and stores the returned value to the variable
+     * <code>rowCount</code>.
+     */
+    public void _getAccessibleRowCount() {
+        rowCount = oObj.getAccessibleRowCount();
+        log.println("Accessible row count: " + rowCount);
+        tRes.tested("getAccessibleRowCount()", true);
+    }
+
+    int colCount = 0;
+
+    /**
+     * Calls the method and stores the returned value to the variable
+     * <code>colCount</code>.
+     */
+    public void _getAccessibleColumnCount() {
+        colCount = oObj.getAccessibleColumnCount();
+        log.println("Accessible column count: " + colCount);
+        tRes.tested("getAccessibleColumnCount()", true);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct index,
+     * checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value isn't <code>null</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleRowDescription() {
+        requiredMethod("getAccessibleRowCount()");
+        boolean res = true;
+
+        try {
+            log.print("getAccessibleRowDescription(-1): ");
+            String descr = oObj.getAccessibleRowDescription(-1);
+            log.println("'" + descr + "'");
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRowDescription(" + rowCount + "): ");
+            String descr = oObj.getAccessibleRowDescription(rowCount);
+            log.println("'" + descr + "'");
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRowDescription(" + (rowCount - 1) + "): ");
+            String descr =
+                oObj.getAccessibleRowDescription(rowCount - 1);
+            res &= descr != null;
+            log.println("'" + descr + "'");
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleRowDescription()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct index,
+     * checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value isn't <code>null</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleColumnDescription() {
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+
+        try {
+            log.print("getAccessibleColumnDescription(-1): ");
+            String descr = oObj.getAccessibleColumnDescription(-1);
+            log.println("'" + descr + "'");
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumnDescription(" + colCount + "): ");
+            String descr = oObj.getAccessibleColumnDescription(colCount);
+            log.println("'" + descr + "'");
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumnDescription(" + (colCount - 1) + "): ");
+            String descr =
+                oObj.getAccessibleColumnDescription(colCount - 1);
+            res &= descr != null;
+            log.println("'" + descr + "'");
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleColumnDescription()", res);
+    }
+
+
+     /**
+     * Calls the method with the wrong parameters and with the correct
+     * parameters, checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value is greater than or is equal to 1.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleRowExtentAt() {
+        requiredMethod("getAccessibleRowCount()");
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+
+        try {
+            log.print("getAccessibleRowExtentAt(-1," + (colCount-1) + "):");
+            int ext = oObj.getAccessibleRowExtentAt(-1, colCount - 1);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRowExtentAt(" + (rowCount-1) + ",-1):");
+            int ext = oObj.getAccessibleRowExtentAt(rowCount - 1, -1);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRowExtentAt(0," + colCount + "):");
+            int ext = oObj.getAccessibleRowExtentAt(0, colCount);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRowExtentAt(" + rowCount + ",0):");
+            int ext = oObj.getAccessibleRowExtentAt(rowCount, 0);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRowExtentAt(" +
+                (rowCount-1) + "," + (colCount-1) + "):");
+            int ext = oObj.getAccessibleRowExtentAt(rowCount-1, colCount - 1);
+            log.println(ext);
+            res &= ext >= 1;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleRowExtentAt()", res);
+    }
+
+    /**
+     * Calls the method with the wrong parameters and with the correct
+     * parameters, checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value is greater than or is equal to 1.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleColumnExtentAt() {
+        requiredMethod("getAccessibleRowCount()");
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+
+        try {
+            log.print("getAccessibleColumnExtentAt(-1," + (colCount-1) + "):");
+            int ext = oObj.getAccessibleColumnExtentAt(-1, colCount - 1);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumnExtentAt(" + (rowCount-1) + ",-1):");
+            int ext = oObj.getAccessibleColumnExtentAt(rowCount - 1, -1);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumnExtentAt(0," + colCount + "):");
+            int ext = oObj.getAccessibleColumnExtentAt(0, colCount);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumnExtentAt(" + rowCount + ",0):");
+            int ext = oObj.getAccessibleColumnExtentAt(rowCount, 0);
+            log.println(ext);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumnExtentAt(" +
+                (rowCount-1) + "," + (colCount-1) + "):");
+            int ext = oObj.getAccessibleColumnExtentAt(rowCount-1,colCount - 1);
+            log.println(ext);
+            res &= ext >= 1;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleColumnExtentAt()", res);
+    }
+
+    /**
+     * Calls the method and checks a returned value.
+     * Has OK status if returned value isn't <code>null</code>.
+     */
+    public void _getAccessibleRowHeaders() {
+        XAccessibleTable rowHeaders = oObj.getAccessibleRowHeaders();
+        log.println("getAccessibleRowHeaders(): " + rowHeaders);
+        tRes.tested("getAccessibleRowHeaders()", true);
+    }
+
+    /**
+     * Calls the method and checks a returned value.
+     * Has OK status if returned value isn't <code>null</code>.
+     */
+    public void _getAccessibleColumnHeaders() {
+        XAccessibleTable colHeaders = oObj.getAccessibleColumnHeaders();
+        log.println("getAccessibleColumnHeaders(): " + colHeaders);
+        tRes.tested("getAccessibleColumnHeaders()", true);
+    }
+
+    /**
+     * If the interface <code>XAccessibleSelection</code> is supported by
+     * the component than selects all accessible children.
+     * Calls the method and checks a returned sequence.
+     * Has OK status if a returned sequince is in ascending order.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _getSelectedAccessibleRows() {
+        requiredMethod("getAccessibleRowCount()");
+        boolean res = true;
+        boolean locRes = true;
+        int selRows[] = null;
+
+        if (xASel != null) {
+            log.println("XAccessibleSelection.selectAllAccessibleChildren()");
+            xASel.selectAllAccessibleChildren();
+        }
+
+        log.println("getSelectedAccessibleRows()");
+        selRows = oObj.getSelectedAccessibleRows();
+        log.println("Length of the returned sequince: " + selRows.length);
+        if (xASel != null) {
+            res &= selRows.length == rowCount;
+        } else {
+            res &= selRows.length == 0;
+        }
+
+        if (selRows.length > 0) {
+            log.println("Checking that returned sequence is" +
+                " in ascending order");
+        }
+
+        for(int i = 1; i < selRows.length; i++) {
+            locRes &= selRows[i] >= selRows[i - 1];
+            res &= locRes;
+            if (!locRes) {
+                log.println("Element #" + i + ":" + selRows[i] +
+                    " is less than element #" + (i-1) + ": " +
+                    selRows[i-1]);
+                break;
+            }
+        }
+
+        tRes.tested("getSelectedAccessibleRows()", res);
+    }
+
+    /**
+     * If the interface <code>XAccessibleSelection</code> is supported by
+     * the component than selects all accessible children.
+     * Calls the method and checks a returned sequence.
+     * Has OK status if a returned sequince is in ascending order.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     * </ul>
+     */
+    public void _getSelectedAccessibleColumns() {
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+        boolean locRes = true;
+        int selCols[] = null;
+
+        if (xASel != null) {
+            log.println("XAccessibleSelection.selectAllAccessibleChildren()");
+            xASel.selectAllAccessibleChildren();
+        }
+
+        log.println("getSelectedAccessibleColumns()");
+        selCols = oObj.getSelectedAccessibleColumns();
+        log.println("Length of the returned sequince: " + selCols.length);
+
+        if (xASel != null) {
+            res &= selCols.length == colCount;
+        } else {
+            res &= selCols.length == 0;
+        }
+
+        if (selCols.length > 0) {
+            log.println("Checking that returned sequence is" +
+                " in ascending order");
+        }
+
+        for(int i = 1; i < selCols.length; i++) {
+            locRes &= selCols[i] >= selCols[i - 1];
+            res &= locRes;
+            if (!locRes) {
+                log.println("Element #" + i + ":" + selCols[i] +
+                    " is less than element #" + (i-1) + ": " +
+                    selCols[i-1]);
+                break;
+            }
+        }
+
+        tRes.tested("getSelectedAccessibleColumns()", res);
+    }
+
+    /**
+     * Calls the method with invalid indexes.
+     * If the interface <code>XAccessibleSelection</code> is supported by
+     * the component than selects all accessible children.
+     * Calls the method for every row and checks returned values.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _isAccessibleRowSelected() {
+        requiredMethod("getAccessibleRowCount()");
+        boolean res = true;
+        boolean locRes = true;
+
+        try {
+            log.print("isAccessibleRowSelected(-1): ");
+            locRes = oObj.isAccessibleRowSelected(-1);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("isAccessibleRowSelected(" + rowCount + "): ");
+            locRes = oObj.isAccessibleRowSelected(rowCount);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        if (xASel != null) {
+            log.println("XAccessibleSelection.selectAllAccessibleChildren()");
+            xASel.selectAllAccessibleChildren();
+        }
+
+        try {
+            log.println("Checking of every row selection...");
+            for(int i = 0; i < rowCount; i++) {
+                boolean isSel = oObj.isAccessibleRowSelected(i);
+                locRes = (xASel == null) ? !isSel : isSel;
+                res &= locRes;
+                if (!locRes) {
+                    log.println("isAccessibleRowSelected(" + i + "): " + isSel);
+                    break;
+                }
+            }
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("isAccessibleRowSelected()", res);
+    }
+
+    /**
+     * Calls the method with invalid indexes.
+     * If the interface <code>XAccessibleSelection</code> is supported by
+     * the component than selects all accessible children.
+     * Calls the method for every column and checks returned values.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _isAccessibleColumnSelected() {
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+        boolean locRes = true;
+
+        try {
+            log.print("isAccessibleColumnSelected(-1): ");
+            locRes = oObj.isAccessibleColumnSelected(-1);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("isAccessibleColumnSelected(" + colCount + "): ");
+            locRes = oObj.isAccessibleColumnSelected(colCount);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        if (xASel != null) {
+            log.println("XAccessibleSelection.selectAllAccessibleChildren()");
+            xASel.selectAllAccessibleChildren();
+        }
+
+        try {
+            log.println("Checking of every column selection...");
+            for(int i = 0; i < colCount; i++) {
+                boolean isSel = oObj.isAccessibleColumnSelected(i);
+                locRes = (xASel == null) ? !isSel : isSel;
+                res &= locRes;
+                if (!locRes) {
+                    log.println("isAccessibleColumnSelected(" + i + "): " + isSel);
+                    break;
+                }
+            }
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("isAccessibleColumnSelected()", res);
+    }
+
+    XAccessible xCellAc = null;
+
+    /**
+     * Calls the method with the wrong parameters and with the correct
+     * parameter, checks a returned value and stores it to the variable
+     * <code>xCellAc</code>.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value isn't null.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleCellAt() {
+        requiredMethod("getAccessibleRowCount()");
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+
+        try {
+            log.print("getAccessibleCellAt(-1," + (colCount-1) + "):");
+            xCellAc = oObj.getAccessibleCellAt(-1, colCount - 1);
+            log.println(xCellAc);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleCellAt(" + (rowCount-1) + ",-1):");
+            xCellAc = oObj.getAccessibleCellAt(rowCount - 1, -1);
+            log.println(xCellAc);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleCellAt(0, " + colCount + "):");
+            xCellAc = oObj.getAccessibleCellAt(0, colCount);
+            log.println(xCellAc);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleCellAt(" + rowCount + ",0):");
+            XAccessible xCellAc = oObj.getAccessibleCellAt(rowCount, 0);
+            log.println(xCellAc);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleCellAt(" + (rowCount-1) + "," +
+                (colCount-1) + "): ");
+            xCellAc = oObj.getAccessibleCellAt(
+                rowCount - 1, colCount - 1);
+            log.println(xCellAc);
+            res &= xCellAc != null;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleCellAt()", res);
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getAccessibleCaption() {
+        XAccessible caption = oObj.getAccessibleCaption();
+        log.println("getAccessibleCaption(): " + caption);
+        tRes.tested("getAccessibleCaption()", true);
+    }
+
+    /**
+     * Just calls the method.
+     */
+    public void _getAccessibleSummary() {
+        XAccessible summary = oObj.getAccessibleSummary();
+        log.println("getAccessibleSummary(): " + summary);
+        tRes.tested("getAccessibleSummary()", true);
+    }
+
+    /**
+     * Calls the method with the wrong parameters and with the correct
+     * parameter, checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _isAccessibleSelected() {
+        requiredMethod("getAccessibleRowCount()");
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+        boolean locRes = true;
+
+        try {
+            log.print("isAccessibleSelected(-1," + (colCount-1) + "):");
+            locRes = oObj.isAccessibleSelected(-1, colCount - 1);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("isAccessibleSelected(" + (rowCount-1) + ",-1):");
+            locRes = oObj.isAccessibleSelected(rowCount - 1, -1);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("isAccessibleSelected(0, " + colCount + "):");
+            locRes = oObj.isAccessibleSelected(0, colCount);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("isAccessibleSelected(" + rowCount + ",0):");
+            locRes = oObj.isAccessibleSelected(rowCount, 0);
+            log.println(locRes);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        if (xASel != null) {
+            log.println("XAccessibleSelection.selectAllAccessibleChildren()");
+            xASel.selectAllAccessibleChildren();
+        }
+
+        try {
+            log.print("isAccessibleSelected(" + (rowCount-1) + "," +
+                (colCount-1) + "): ");
+            boolean isSel = oObj.isAccessibleSelected(
+                rowCount - 1, colCount - 1);
+            log.println(isSel);
+            locRes = (xASel == null) ? !isSel : isSel ;
+            res &= locRes;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("isAccessibleSelected()", res);
+    }
+
+    /**
+     * Calls the method with the wrong parameters and with the correct
+     * parameter, checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value is equal to value returned by calling
+     * <code>XAccessibleContext::getAccessibleIndexInParent</code> for the cell.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleCellAt()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleIndex() {
+        executeMethod("getAccessibleCellAt()");
+        boolean res = true;
+
+        try {
+            log.print("getAccessibleIndex(-1," + (colCount-1) + "):");
+            int indx = oObj.getAccessibleIndex(-1, colCount - 1);
+            log.println(indx);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleIndex(" + (rowCount-1) + ",-1):");
+            int indx = oObj.getAccessibleIndex(rowCount - 1, -1);
+            log.println(indx);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleIndex(0," + colCount + "):");
+            int indx = oObj.getAccessibleIndex(0, colCount);
+            log.println(indx);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleIndex(" + rowCount + ",0):");
+            int indx = oObj.getAccessibleIndex(rowCount, 0);
+            log.println(indx);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleIndex(" + (rowCount-1) + "," +
+                (colCount-1) + "): ");
+            int indx = oObj.getAccessibleIndex(
+                rowCount - 1, colCount - 1);
+            log.println(indx);
+            if (xCellAc != null) {
+                XAccessibleContext xAC = xCellAc.getAccessibleContext();
+                int expIndx = xAC.getAccessibleIndexInParent();
+                log.println("Expected index: " + expIndx);
+                res &= expIndx == indx;
+            } else {
+                res &= true;
+            }
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleIndex()", res);
+    }
+
+    /**
+     * Receives an accessible child count using the interface
+     * <code>XAccessibleContext</code>.
+     * Calls the method with the wrong parameters and with the correct
+     * parameter, checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value is greater than zero and is less than
+     * accessible row count.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleRowCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleRow() {
+        requiredMethod("getAccessibleRowCount()");
+        boolean res = true;
+
+        if (xACont != null) {
+            int childCount = xACont.getAccessibleChildCount();
+            log.println("accessible child count: " + childCount);
+
+            try {
+                log.print("getAccessibleRow(" + childCount + "): ");
+                int rowIndx = oObj.getAccessibleRow(childCount);
+                log.println(rowIndx);
+                log.println("Exception was expected");
+                res &= false;
+            } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+                log.println("expected exception");
+                res &= true;
+            }
+
+            try {
+                log.print("getAccessibleRow(" + (childCount-1) + "): ");
+                int rowIndx = oObj.getAccessibleRow(childCount - 1);
+                log.println(rowIndx);
+                res &= (rowIndx >= 0 && rowIndx <= rowCount);
+            } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+                log.println("Unexpected exception");
+                e.printStackTrace(log);
+                res &= false;
+            }
+        }
+
+        try {
+            log.print("getAccessibleRow(-1): ");
+            int rowIndx = oObj.getAccessibleRow(-1);
+            log.println(rowIndx);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleRow(0): ");
+            int rowIndx = oObj.getAccessibleRow(0);
+            log.println(rowIndx);
+            res &= (rowIndx >= 0 && rowIndx <= rowCount);
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleRow()", res);
+    }
+
+    /**
+     * Receives an accessible child count using the interface
+     * <code>XAccessibleContext</code>.
+     * Calls the method with the wrong parameters and with the correct
+     * parameter, checks a returned value.
+     * Has OK status if exceptions were thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value is greater than zero and is less than
+     * accessible column count.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getAccessibleColumnCount()</code> </li>
+     * </ul>
+     */
+    public void _getAccessibleColumn() {
+        requiredMethod("getAccessibleColumnCount()");
+        boolean res = true;
+
+        if (xACont != null) {
+            int childCount = xACont.getAccessibleChildCount();
+            log.println("accessible child count: " + childCount);
+
+            try {
+                log.print("getAccessibleColumn(" + childCount + "): ");
+                int colIndx = oObj.getAccessibleColumn(childCount);
+                log.println(colIndx);
+                log.println("Exception was expected");
+                res &= false;
+            } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+                log.println("expected exception");
+                res &= true;
+            }
+
+            try {
+                log.print("getAccessibleColumn(" + (childCount-1) + "): ");
+                int colIndx = oObj.getAccessibleColumn(childCount - 1);
+                log.println(colIndx);
+                res &= (colIndx >= 0 && colIndx <= colCount);
+            } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+                log.println("Unexpected exception");
+                e.printStackTrace(log);
+                res &= false;
+            }
+        }
+
+        try {
+            log.print("getAccessibleColumn(-1): ");
+            int colIndx = oObj.getAccessibleColumn(-1);
+            log.println(colIndx);
+            log.println("Exception was expected");
+            res &= false;
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getAccessibleColumn(0): ");
+            int colIndx = oObj.getAccessibleColumn(0);
+            log.println(colIndx);
+            res &= (colIndx >= 0 && colIndx <= rowCount);
+        } catch(com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getAccessibleColumn()", res);
+    }
+}
\ No newline at end of file
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleText.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleText.java
new file mode 100644
index 000000000..b4dd7d674
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleText.java
@@ -0,0 +1,1208 @@
+/*
+ * 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 lib.MultiMethodTest;
+import lib.Status;
+import lib.StatusException;
+
+import com.sun.star.accessibility.AccessibleTextType;
+import com.sun.star.accessibility.TextSegment;
+import com.sun.star.accessibility.XAccessibleComponent;
+import com.sun.star.accessibility.XAccessibleText;
+import com.sun.star.awt.Point;
+import com.sun.star.awt.Rectangle;
+import com.sun.star.beans.PropertyValue;
+import com.sun.star.uno.UnoRuntime;
+
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleText</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> getCaretPosition()</code></li>
+ *  <li><code> setCaretPosition()</code></li>
+ *  <li><code> getCharacter()</code></li>
+ *  <li><code> getCharacterAttributes()</code></li>
+ *  <li><code> getCharacterBounds()</code></li>
+ *  <li><code> getCharacterCount()</code></li>
+ *  <li><code> getIndexAtPoint()</code></li>
+ *  <li><code> getSelectedText()</code></li>
+ *  <li><code> getSelectionStart()</code></li>
+ *  <li><code> getSelectionEnd()</code></li>
+ *  <li><code> setSelection()</code></li>
+ *  <li><code> getText()</code></li>
+ *  <li><code> getTextRange()</code></li>
+ *  <li><code> getTextAtIndex()</code></li>
+ *  <li><code> getTextBeforeIndex()</code></li>
+ *  <li><code> getTextBehindIndex()</code></li>
+ *  <li><code> copyText()</code></li>
+ * </ul> <p>
+ * This test needs the following object relations :
+ * <ul>
+ *  <li> <code>'XAccessibleText.Text'</code> (of type <code>String</code>)
+ *   <b> optional </b> :
+ *   the string presentation of component's text. If the relation
+ *   is not specified, then text from method <code>getText()</code>
+ *   is used.
+ *  </li>
+ *  </ul> <p>
+ * @see com.sun.star.accessibility.XAccessibleText
+ */
+public class _XAccessibleText extends MultiMethodTest {
+
+    public XAccessibleText oObj = null;
+    protected com.sun.star.awt.Rectangle bounds = null;
+    String text = null;
+    String editOnly = null;
+    Object LimitedBounds = null;
+    Rectangle chBounds = null;
+    int chCount = 0;
+
+
+    /**
+     * Retrieves a string representation of the component's text.
+     * The length of retrieved string must be greater than zero.
+     */
+    @Override
+    protected void before() {
+        Object xat = tEnv.getObjRelation("XAccessibleText");
+
+        XAccessibleComponent component = null;
+
+        if (xat != null) {
+            oObj = UnoRuntime.queryInterface(
+                           XAccessibleText.class, xat);
+            component = UnoRuntime.queryInterface(
+                                XAccessibleComponent.class, xat);
+        }
+
+        text = (String) tEnv.getObjRelation("XAccessibleText.Text");
+
+        if (text == null) {
+            text = oObj.getText();
+        }
+
+        if (text.length() == 0) {
+            throw new StatusException(Status.failed(
+                                              "The length of text must be greater than zero"));
+        }
+
+        editOnly = (String) tEnv.getObjRelation("EditOnly");
+        LimitedBounds = tEnv.getObjRelation("LimitedBounds");
+
+        if (component == null) {
+            component = UnoRuntime.queryInterface(
+                                XAccessibleComponent.class,
+                                tEnv.getTestObject());
+        }
+
+        bounds = component.getBounds();
+
+        log.println("Text is '" + text + "'");
+        System.out.println("############################");
+    }
+
+    /**
+     * Calls the method and checks returned value.
+     * Has OK status if returned value is equal to <code>chCount - 1</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>setCaretPosition()</code> </li>
+     * </ul>
+     */
+    public void _getCaretPosition() {
+        requiredMethod("getCharacterCount()");
+
+        if (editOnly != null) {
+            log.println(editOnly);
+            throw new StatusException(Status.skipped(true));
+        }
+
+        boolean res = true;
+        boolean sc = true;
+
+        try {
+            oObj.setCaretPosition(chCount - 1);
+        } catch (com.sun.star.lang.IndexOutOfBoundsException ie) {
+        }
+
+        int carPos = oObj.getCaretPosition();
+        log.println("getCaretPosition: " + carPos);
+
+        if (sc) {
+            res = carPos == (chCount - 1);
+        } else {
+            log.println(
+                    "Object is read only and Caret position couldn't be set");
+            res = carPos == -1;
+        }
+
+        tRes.tested("getCaretPosition()", res);
+    }
+
+    /**
+     * Calls the method with the wrong index and with the correct index
+     * <code>chCount - 1</code>.
+     * Has OK status if exception was thrown for wrong index and
+     * if exception wasn't thrown for the correct index.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _setCaretPosition() {
+        requiredMethod("getCharacterCount()");
+
+        boolean res = true;
+
+        try {
+            log.print("setCaretPosition(-1):");
+            oObj.setCaretPosition(-1);
+            res &= false;
+            log.println("exception was expected ... FAILED");
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("setCaretPosition(chCount+1):");
+            oObj.setCaretPosition(chCount + 1);
+            res &= false;
+            log.println("exception was expected  ... FAILED");
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("expected exception");
+            res &= true;
+        }
+
+        try {
+            log.println("setCaretPosition(chCount - 1)");
+            oObj.setCaretPosition(chCount - 1);
+            res &= true;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("unexpected exception  ... FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("setCaretPosition()", res);
+    }
+
+    /**
+     * Calls the method with the wrong index and with the correct indexes.
+     * Checks every character in the text.
+     * Has OK status if exception was thrown for wrong index,
+     * if exception wasn't thrown for the correct index and
+     * if every character is equal to corresponding character in the text.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getCharacter() {
+        requiredMethod("getCharacterCount()");
+
+        boolean res = true;
+
+        try {
+            log.println("getCharacter(-1)");
+            oObj.getCharacter(-1);
+            log.println("Exception was expected");
+            res = false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res = true;
+        }
+
+        try {
+            log.println("getCharacter(chCount)");
+            oObj.getCharacter(chCount);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.println("Checking of every character in the text...");
+
+            boolean isEqCh = true;
+
+            for (int i = 0; i < chCount; i++) {
+                char ch = oObj.getCharacter(i);
+                isEqCh = ch == text.charAt(i);
+                res &= isEqCh;
+
+                if (!isEqCh) {
+                    log.println("At the position " + i +
+                                "was expected character: " + text.charAt(i));
+                    log.println("but was returned: " + ch);
+
+                    break;
+                }
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getCharacter()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct index,
+     * checks a returned value.
+     * Has OK status if exception was thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value isn't <code>null</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getCharacterAttributes() {
+        requiredMethod("getCharacterCount()");
+
+        boolean res = true;
+        String[] attr = new String[] { "" };
+
+        try {
+            log.println("getCharacterAttributes(-1)");
+            oObj.getCharacterAttributes(-1, attr);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch(com.sun.star.beans.UnknownPropertyException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        try {
+            log.println("getCharacterAttributes(chCount = " + chCount + ")");
+            oObj.getCharacterAttributes(chCount, attr);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch(com.sun.star.beans.UnknownPropertyException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        try {
+            log.println(
+                "getCharacterAttributes(chCount-1 = " + (chCount - 1) + ")");
+
+            PropertyValue[] props = oObj.getCharacterAttributes(chCount - 1,
+                                                                attr);
+            res &= (props != null);
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        } catch(com.sun.star.beans.UnknownPropertyException e) {
+            log.println("unexpected exception => FAILED");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getCharacterAttributes()", res);
+    }
+
+    /**
+     * Calls the method with the wrong indexes and with the correct index.
+     * checks and stores a returned value.
+     * Has OK status if exception was thrown for the wrong indexes,
+     * if exception wasn't thrown for the correct index and
+     * if returned value isn't <code>null</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getCharacterBounds() {
+        requiredMethod("getCharacterCount()");
+
+        boolean res = true;
+
+        int lastIndex = chCount;
+
+        if (LimitedBounds != null) {
+            if (LimitedBounds instanceof Integer) {
+                lastIndex = ((Integer) LimitedBounds).intValue();
+            } else {
+                lastIndex = chCount - 1;
+            }
+
+            log.println(LimitedBounds);
+        }
+
+        try {
+            log.println("getCharacterBounds(-1)");
+            oObj.getCharacterBounds(-1);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.println("getCharacterBounds(" + (lastIndex + 1) + ")");
+            oObj.getCharacterBounds(lastIndex + 1);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            for (int i = 0; i < lastIndex; i++) {
+                log.println("getCharacterBounds(" + i + ")");
+                chBounds = oObj.getCharacterBounds(i);
+
+                boolean localres = true;
+                localres = chBounds.X >= 0;
+                localres &= (chBounds.Y >= 0);
+                localres &= ((chBounds.X + chBounds.Width) <= bounds.Width);
+                localres &= ((chBounds.X + chBounds.Width) >= 0);
+                localres &= ((chBounds.Y + chBounds.Height) <= bounds.Height);
+                localres &= ((chBounds.Y + chBounds.Height) >= 0);
+
+                if (!localres) {
+                    log.println("Text at this place: "+oObj.getCharacter(i));
+                    log.println("Character bounds outside component");
+                    log.println("Character rect: " + chBounds.X + ", " +
+                                chBounds.Y + ", " + chBounds.Width + ", " +
+                                chBounds.Height);
+                    log.println("Component rect: " + bounds.X + ", " +
+                                bounds.Y + ", " + bounds.Width + ", " +
+                                bounds.Height);
+                }
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getCharacterBounds()", res);
+    }
+
+    /**
+     * Calls the method and stores a returned value to the variable
+     * <code>chCount</code>.
+     * Has OK status if a returned value is equal to the text length.
+     */
+    public void _getCharacterCount() {
+        chCount = oObj.getCharacterCount();
+        log.println("Character count:" + chCount);
+
+        boolean res = chCount == text.length();
+        tRes.tested("getCharacterCount()", res);
+    }
+
+    /**
+     * Calls the method for an invalid point and for the point of rectangle
+     * returned by the method <code>getCharacterBounds()</code>.
+     * Has OK status if returned value is equal to <code>-1</code> for an
+     * invalid point and if returned value is equal to <code>chCount-1</code>
+     * for a valid point.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterBounds()</code> </li>
+     * </ul>
+     */
+    public void _getIndexAtPoint() {
+        //requiredMethod("getCharacterBounds()");
+        boolean res = true;
+        log.print("getIndexAtPoint(-1, -1):");
+
+        Point pt = new Point(-1, -1);
+        int index = oObj.getIndexAtPoint(pt);
+        log.println(index);
+        res &= (index == -1);
+
+        int lastIndex = chCount;
+
+        if (LimitedBounds != null) {
+            if (LimitedBounds instanceof Integer) {
+                lastIndex = ((Integer) LimitedBounds).intValue();
+            } else {
+                lastIndex = chCount - 1;
+            }
+
+            log.println(LimitedBounds);
+        }
+
+        for (int i = 0; i < lastIndex; i++) {
+            Rectangle aRect = null;
+            String text = "empty";
+
+            try {
+                aRect = oObj.getCharacterBounds(i);
+                text = oObj.getTextAtIndex(i, (short) 1).SegmentText;
+            } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            } catch (com.sun.star.lang.IllegalArgumentException e) {
+            }
+
+            if (aRect == null) {
+                res = false;
+                log.print("aRect unexpected null");
+                break;
+            }
+
+            int x = aRect.X + (aRect.Width / 2);
+            int y = aRect.Y + (aRect.Height / 2);
+
+            Point aPoint = new Point(x, y);
+            int nIndex = oObj.getIndexAtPoint(aPoint);
+
+            x = aRect.X;
+            y = aRect.Y + (aRect.Height / 2);
+            aPoint = new Point(x, y);
+            int left = oObj.getIndexAtPoint(aPoint);
+
+
+
+            int[] previous = (int[]) tEnv.getObjRelation("PreviousUsed");
+
+            if (previous != null) {
+                for (int k = 0; k < previous.length; k++) {
+                    if (i == previous[k]) {
+                        nIndex++;
+                    }
+                }
+            }
+
+            if (nIndex != i) {
+                // for some letters the center of the rectangle isn't recognised
+                // in this case we are happy if the left border of the rectangle
+                // returns the correct value.
+                if (left !=i) {
+                    log.println("## Method didn't work for Point (" + x + "," + y +
+                            ")");
+                    log.println("Expected Index " + i);
+                    log.println("Gained Index: " + nIndex);
+                    log.println("Left Border: "+left);
+                    log.println("CharacterAtIndex: " + text);
+                    res &= false;
+                }
+            }
+        }
+
+        tRes.tested("getIndexAtPoint()", res);
+    }
+
+    /**
+     * Checks a returned values after different calls of the method
+     * <code>setSelection()</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>setSelection()</code> </li>
+     * </ul>
+     */
+    public void _getSelectedText() {
+        if (editOnly != null) {
+            log.println(editOnly);
+            throw new StatusException(Status.skipped(true));
+        }
+
+        requiredMethod("setSelection()");
+
+        boolean res = true;
+
+        try {
+            log.println("setSelection(0, 0)");
+            oObj.setSelection(0, 0);
+            log.print("getSelectedText():");
+
+            String txt = oObj.getSelectedText();
+            log.println("'" + txt + "'");
+            res &= (txt.length() == 0);
+
+            log.println("setSelection(0, chCount)");
+            oObj.setSelection(0, chCount);
+            log.print("getSelectedText():");
+            txt = oObj.getSelectedText();
+            log.println("'" + txt + "'");
+            res &= txt.equals(text);
+
+            if (chCount > 2) {
+                log.println("setSelection(1, chCount-1)");
+                oObj.setSelection(1, chCount - 1);
+                log.print("getSelectedText():");
+                txt = oObj.getSelectedText();
+                log.println("'" + txt + "'");
+                res &= txt.equals(text.substring(1, chCount - 1));
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getSelectedText()", res);
+    }
+
+    /**
+     * Checks a returned values after different calls of the method
+     * <code>setSelection()</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>setSelection()</code> </li>
+     * </ul>
+     */
+    public void _getSelectionStart() {
+        if (editOnly != null) {
+            log.println(editOnly);
+            throw new StatusException(Status.skipped(true));
+        }
+
+        requiredMethod("setSelection()");
+
+        boolean res = true;
+
+        try {
+            log.println("setSelection(0, chCount)");
+            oObj.setSelection(0, chCount);
+
+            int start = oObj.getSelectionStart();
+            log.println("getSelectionStart():" + start);
+            res &= (start == 0);
+
+            if (chCount > 2) {
+                log.println("setSelection(1, chCount-1)");
+                oObj.setSelection(1, chCount - 1);
+                start = oObj.getSelectionStart();
+                log.println("getSelectionStart():" + start);
+                res &= (start == 1);
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getSelectionStart()", res);
+    }
+
+    /**
+     * Checks a returned values after different calls of the method
+     * <code>setSelection()</code>.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>setSelection()</code> </li>
+     * </ul>
+     */
+    public void _getSelectionEnd() {
+        if (editOnly != null) {
+            log.println(editOnly);
+            throw new StatusException(Status.skipped(true));
+        }
+
+        requiredMethod("setSelection()");
+
+        boolean res = true;
+
+        try {
+            log.println("setSelection(0, chCount)");
+            oObj.setSelection(0, chCount);
+
+            int end = oObj.getSelectionEnd();
+            log.println("getSelectionEnd():" + end);
+            res &= (end == chCount);
+
+            if (chCount > 2) {
+                log.println("setSelection(1, chCount-1)");
+                oObj.setSelection(1, chCount - 1);
+                end = oObj.getSelectionEnd();
+                log.println("getSelectionEnd():" + end);
+                res &= (end == (chCount - 1));
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getSelectionEnd()", res);
+    }
+
+    /**
+     * Calls the method with invalid parameters and with valid parameters.
+     * Has OK status if exception was thrown for invalid parameters,
+     * if exception wasn't thrown for valid parameters.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _setSelection() {
+        requiredMethod("getCharacterCount()");
+
+        boolean res = true;
+        boolean locRes = true;
+
+        if (editOnly != null) {
+            log.println(editOnly);
+            throw new StatusException(Status.skipped(true));
+        }
+
+        try {
+            log.print("setSelection(-1, chCount-1):");
+            locRes = oObj.setSelection(-1, chCount - 1);
+            log.println(locRes + " exception was expected");
+            res &= !locRes;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("setSelection(0, chCount+1):");
+            locRes = oObj.setSelection(0, chCount + 1);
+            log.println(locRes + " exception was expected");
+            res &= !locRes;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            if (chCount > 2) {
+                log.print("setSelection(1, chCount-1):");
+                locRes = oObj.setSelection(1, chCount - 1);
+                log.println(locRes);
+                res &= locRes;
+
+                log.print("setSelection(chCount-1, 1):");
+                locRes = oObj.setSelection(chCount - 1, 1);
+                log.println(locRes);
+                res &= locRes;
+            }
+
+            log.print("setSelection(0, chCount-1):");
+            locRes = oObj.setSelection(0, chCount - 1);
+            log.println(locRes);
+            res &= locRes;
+
+            log.print("setSelection(chCount-1, 0):");
+            locRes = oObj.setSelection(chCount - 1, 0);
+            log.println(locRes);
+            res &= locRes;
+
+            log.print("setSelection(0, 0):");
+            locRes = oObj.setSelection(0, 0);
+            log.println(locRes);
+            res &= locRes;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("setSelection()", res);
+    }
+
+    /**
+     * Calls the method and checks returned value.
+     * Has OK status if returned string is equal to string
+     * received from relation.
+     */
+    public void _getText() {
+        String txt = oObj.getText();
+        log.println("getText: " + txt);
+
+        boolean res = txt.equals(text);
+        tRes.tested("getText()", res);
+    }
+
+    /**
+     * Calls the method with invalid parameters and with valid parameters,
+     * checks returned values.
+     * Has OK status if exception was thrown for invalid parameters,
+     * if exception wasn't thrown for valid parameters and if returned values
+     * are equal to corresponding substrings of the text received by relation.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getTextRange() {
+        requiredMethod("getCharacterCount()");
+
+        boolean res = true;
+        boolean locRes = true;
+
+        String txtRange = "";
+
+        try {
+            if (chCount > 3) {
+                log.print("getTextRange(1, chCount - 2): ");
+
+                txtRange = oObj.getTextRange(1, chCount - 2);
+                log.println(txtRange);
+                locRes = txtRange.equals(text.substring(1, chCount - 2));
+                res &= locRes;
+
+                if (!locRes) {
+                    log.println("Was expected: " +
+                                text.substring(1, chCount - 2));
+                }
+            }
+
+            log.print("getTextRange(0, chCount-1): ");
+
+            txtRange = oObj.getTextRange(0, chCount - 1);
+            log.println(txtRange);
+            locRes = txtRange.equals(text.substring(0, chCount - 1));
+            res &= locRes;
+
+            if (!locRes) {
+                log.println("Was expected: " +
+                            text.substring(0, chCount - 1));
+            }
+
+            log.print("getTextRange(chCount, 0): ");
+            txtRange = oObj.getTextRange(chCount, 0);
+            log.println(txtRange);
+            res &= txtRange.equals(text);
+
+            log.print("getTextRange(0, 0): ");
+            txtRange = oObj.getTextRange(0, 0);
+            log.println(txtRange);
+            locRes = txtRange.equals("");
+            res &= locRes;
+
+            if (!locRes) {
+                log.println("Empty string was expected");
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        try {
+            log.print("getTextRange(-1, chCount - 1): ");
+
+            txtRange = oObj.getTextRange(-1, chCount - 1);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getTextRange(0, chCount + 1): ");
+
+            txtRange = oObj.getTextRange(0, chCount + 1);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getTextRange(chCount+1, -1): ");
+
+            txtRange = oObj.getTextRange(chCount + 1, -1);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        tRes.tested("getTextRange()", res);
+    }
+
+    /**
+     * Calls the method with invalid parameters and with valid parameters,
+     * checks returned values.
+     * Has OK status if exception was thrown for invalid parameters,
+     * if exception wasn't thrown for valid parameters and if returned values
+     * are equal to corresponding substrings of the text received by relation.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getTextAtIndex() {
+        requiredMethod("getCharacterCount()");
+        TextSegment txt = null;
+        boolean res = true;
+
+        try {
+            log.print("getTextAtIndex(-1, AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextAtIndex(-1,
+                                                  AccessibleTextType.PARAGRAPH);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("UnExpected exception");
+            res &= false;
+        }
+
+        try {
+            log.print("getTextAtIndex(chCount+1," +
+                      " AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextAtIndex(chCount + 1,
+                                                  AccessibleTextType.PARAGRAPH);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("UnExpected exception");
+            res &= false;
+        }
+
+        try {
+            log.print("getTextAtIndex(chCount," +
+                      " AccessibleTextType.WORD):");
+
+            txt = oObj.getTextAtIndex(chCount, AccessibleTextType.WORD);
+            log.println("'" + txt.SegmentText + "'");
+            res &= compareLength(0,txt.SegmentText);
+            if (!tEnv.getTestCase().getObjectName().equals("SmGraphicAccessible")) {
+                log.print("getTextAtIndex(1," +
+                          " AccessibleTextType.PARAGRAPH):");
+                txt = oObj.getTextAtIndex(1, AccessibleTextType.PARAGRAPH);
+                log.println("'" + txt.SegmentText + "'");
+                res &= compareStrings(text,txt.SegmentText);
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getTextAtIndex()", res);
+    }
+
+    /**
+     * Calls the method with invalid parameters and with valid parameters,
+     * checks returned values.
+     * Has OK status if exception was thrown for invalid parameters,
+     * if exception wasn't thrown for valid parameters and if returned values
+     * are equal to corresponding substrings of the text received by relation.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getTextBeforeIndex() {
+        requiredMethod("getCharacterCount()");
+        TextSegment txt = null;
+        boolean res = true;
+
+        try {
+            log.print("getTextBeforeIndex(-1, AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextBeforeIndex(-1,
+                                                      AccessibleTextType.PARAGRAPH);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("UnExpected exception");
+            res &= false;
+        }
+
+        try {
+            log.print("getTextBeforeIndex(chCount+1, " +
+                      "AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextBeforeIndex(chCount + 1,
+                                                      AccessibleTextType.PARAGRAPH);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("UnExpected exception");
+            res &= true;
+        }
+
+        try {
+            if (!tEnv.getTestCase().getObjectName().equals("SmGraphicAccessible")
+                // next one fails because the control actually contains 2 words
+                && !tEnv.getTestCase().getObjectName().equals("AccessibleStatusBarItem"))
+            {
+                log.print("getTextBeforeIndex(chCount," +
+                          " AccessibleTextType.WORD):");
+
+                txt = oObj.getTextBeforeIndex(chCount,
+                                                     AccessibleTextType.WORD);
+                log.println("'" + txt.SegmentText + "'");
+                res &= compareLength(chCount, txt.SegmentText);
+            }
+
+            log.print("getTextBeforeIndex(1," +
+                      " AccessibleTextType.PARAGRAPH):");
+            txt = oObj.getTextBeforeIndex(1, AccessibleTextType.PARAGRAPH);
+            log.println("'" + txt.SegmentText + "'");
+            res &= compareLength(0, txt.SegmentText);
+
+            log.print("getTextBeforeIndex(chCount-1," +
+                      " AccessibleTextType.CHARACTER):");
+            txt = oObj.getTextBeforeIndex(chCount - 1,
+                                          AccessibleTextType.CHARACTER);
+            log.println("'" + txt.SegmentText + "'");
+            res &= compareStrings(text.substring(chCount - 2, chCount - 1),
+                                  txt.SegmentText);
+
+            if (chCount > 2) {
+                log.print("getTextBeforeIndex(2," +
+                          " AccessibleTextType.CHARACTER):");
+                txt = oObj.getTextBeforeIndex(2, AccessibleTextType.CHARACTER);
+                log.println("'" + txt.SegmentText + "'");
+                res &= compareStrings(text.substring(1, 2), txt.SegmentText);
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getTextBeforeIndex()", res);
+    }
+
+    /**
+     * Calls the method with invalid parameters and with valid parameters,
+     * checks returned values.
+     * Has OK status if exception was thrown for invalid parameters,
+     * if exception wasn't thrown for valid parameters and if returned values
+     * are equal to corresponding substrings of the text received by relation.
+     * The following method tests are to be executed before:
+     * <ul>
+     *  <li> <code>getCharacterCount()</code> </li>
+     * </ul>
+     */
+    public void _getTextBehindIndex() {
+        requiredMethod("getCharacterCount()");
+        TextSegment txt = null;
+        boolean res = true;
+
+        try {
+            log.print("getTextBehindIndex(-1, AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextBehindIndex(-1,
+                                                      AccessibleTextType.PARAGRAPH);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("UnExpected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getTextBehindIndex(chCount+1, " +
+                      "AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextBehindIndex(chCount + 1,
+                                                      AccessibleTextType.PARAGRAPH);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("UnExpected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("getTextBehindIndex(chCount," +
+                      " AccessibleTextType.PARAGRAPH):");
+
+            txt = oObj.getTextBehindIndex(chCount,
+                                                 AccessibleTextType.PARAGRAPH);
+            log.println("'" + txt.SegmentText + "'");
+            res &= (txt.SegmentText.length() == 0);
+
+            log.print("getTextBehindIndex(chCount-1," +
+                      " AccessibleTextType.PARAGRAPH):");
+            txt = oObj.getTextBehindIndex(chCount - 1,
+                                          AccessibleTextType.PARAGRAPH);
+            log.println("'" + txt.SegmentText + "'");
+            res &= (txt.SegmentText.length() == 0);
+
+            log.print("getTextBehindIndex(1," +
+                      " AccessibleTextType.CHARACTER):");
+            txt = oObj.getTextBehindIndex(1, AccessibleTextType.CHARACTER);
+            log.println("'" + txt.SegmentText + "'");
+            res &= txt.SegmentText.equals(text.substring(2, 3));
+
+            if (chCount > 2) {
+                log.print("getTextBehindIndex(chCount-2," +
+                          " AccessibleTextType.CHARACTER):");
+                txt = oObj.getTextBehindIndex(chCount - 2,
+                                              AccessibleTextType.CHARACTER);
+                log.println("'" + txt.SegmentText + "'");
+                res &= txt.SegmentText.equals(text.substring(chCount - 1, chCount));
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("getTextBehindIndex()", res);
+    }
+
+    /**
+     * Calls the method with invalid parameters and with valid parameter,
+     * checks returned values.
+     * Has OK status if exception was thrown for invalid parameters,
+     * if exception wasn't thrown for valid parameter and if returned value for
+     * valid parameter is equal to <code>true</code>.
+     */
+    public void _copyText() {
+        boolean res = true;
+        boolean locRes = true;
+
+        if (editOnly != null) {
+            log.println(editOnly);
+            throw new StatusException(Status.skipped(true));
+        }
+
+        try {
+            log.print("copyText(-1,chCount):");
+            oObj.copyText(-1, chCount);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("copyText(0,chCount+1):");
+            oObj.copyText(0, chCount + 1);
+            log.println("Exception was expected");
+            res &= false;
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Expected exception");
+            res &= true;
+        }
+
+        try {
+            log.print("copyText(0,chCount):");
+            locRes = oObj.copyText(0, chCount);
+            log.println(locRes);
+            res &= locRes;
+
+            String cbText = null;
+
+            try {
+                cbText = util.SysUtils.getSysClipboardText(tParam.getMSF());
+            } catch (com.sun.star.uno.Exception e) {
+                log.println("Couldn't access system clipboard :");
+                e.printStackTrace(log);
+            }
+
+            log.println("Clipboard: '" + cbText + "'");
+            res &= text.equals(cbText);
+
+            if (chCount > 2) {
+                log.print("copyText(1,chCount-1):");
+                locRes = oObj.copyText(1, chCount - 1);
+                log.println(locRes);
+                res &= locRes;
+
+                try {
+                    cbText = util.SysUtils.getSysClipboardText(tParam.getMSF());
+                } catch (com.sun.star.uno.Exception e) {
+                    log.println("Couldn't access system clipboard :");
+                    e.printStackTrace(log);
+                }
+
+                log.println("Clipboard: '" + cbText + "'");
+                res &= text.substring(1, chCount - 1).equals(cbText);
+            }
+        } catch (com.sun.star.lang.IndexOutOfBoundsException e) {
+            log.println("Unexpected exception");
+            e.printStackTrace(log);
+            res &= false;
+        }
+
+        tRes.tested("copyText()", res);
+    }
+
+    public boolean compareStrings(String expected, String getting) {
+        boolean res = expected.equals(getting);
+
+        if (!res) {
+            log.println("## The result isn't the expected:");
+            log.println("\tGetting: " + getting);
+            log.println("\tExpected: " + expected);
+        }
+
+        return res;
+    }
+
+    public boolean compareLength(int expected, String getting) {
+        boolean res = (expected == getting.length());
+
+        if (!res) {
+            log.println("## The result isn't the expected:");
+            log.println("\tGetting: " + getting.length());
+            log.println("\tExpected: " + expected);
+        }
+
+        return res;
+    }
+}
diff --git a/qadevOOo/tests/java/ifc/accessibility/_XAccessibleValue.java b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleValue.java
new file mode 100644
index 000000000..b72874768
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/accessibility/_XAccessibleValue.java
@@ -0,0 +1,344 @@
+/*
+ * 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 lib.MultiMethodTest;
+import lib.Status;
+import lib.StatusException;
+
+import com.sun.star.accessibility.XAccessibleValue;
+
+/**
+ * Testing <code>com.sun.star.accessibility.XAccessibleValue</code>
+ * interface methods :
+ * <ul>
+ *  <li><code> getCurrentValue()</code></li>
+ *  <li><code> setCurrentValue()</code></li>
+ *  <li><code> getMaximumValue()</code></li>
+ *  <li><code> getMinimumValue()</code></li>
+ * </ul> <p>
+ *
+ * This test needs the following object relations :
+ * <ul>
+ *  <li> <code>'XAccessibleValue.anotherFromGroup'</code>
+ *  (of type <code>XAccessibleValue</code>) <b> optional </b>:
+ *   another component from the group(e.g. radio button group)</li>
+ *  </ul><p>
+ * @see com.sun.star.accessibility.XAccessibleValue
+ */
+public class _XAccessibleValue extends MultiMethodTest {
+
+    public XAccessibleValue oObj = null;
+
+    private double minVal = 0;
+    private double maxVal = 0;
+    private static final double curVal = 0;
+    private Object val = null;
+    XAccessibleValue anotherFromGroup = null;
+
+    @Override
+    protected void before() {
+        anotherFromGroup = (XAccessibleValue)tEnv.getObjRelation(
+            "XAccessibleValue.anotherFromGroup");
+    }
+
+    /**
+     * Gets current value and stores it as double. <p>
+     *
+     * Has <b> OK </b> status if the current value is between Min and Max
+     * values. <p>
+     *
+     * The following method tests are to be executed before :
+     * <ul>
+     *  <li> <code> getMaximumValue </code> </li>
+     *  <li> <code> getMinimumValue </code> </li>
+     * </ul>
+     */
+    public void _getCurrentValue() {
+        executeMethod("getMaximumValue()");
+        executeMethod("getMinimumValue()");
+
+        boolean result = true;
+
+        double curVal ;
+        val = oObj.getCurrentValue() ;
+        if (util.utils.isVoid(val)) {
+            val = Integer.valueOf(0);
+            curVal = 0;
+        } else  {
+            curVal = getDoubleValue(val);
+        }
+
+        if (curVal < minVal || maxVal < curVal) {
+            log.println((curVal - minVal) + "," + (maxVal - curVal));
+            log.println("Current value " + curVal + " is not in range ["
+                + minVal + "," + maxVal + "]");
+            result = false;
+        }
+
+        tRes.tested("getCurrentValue()", result) ;
+    }
+
+    /**
+     * Performs testing for following cases :
+     * <ul>
+     *  <li> Creates new value in valid range and sets it. </li>
+     *  <li> Sets maximum and minimum values. </li>
+     *  <li> Sets Min - 1, and Max + 1 values </li>
+     * </ul> <p>
+     *
+     * Has <b> OK </b> status if for the first case the value returned
+     * is the same as was set and the method <code>setCurrentValue</code>
+     * returns <code>true</code>.
+     *
+     * In the second if Max and Min values are set and method
+     * <code>setCurrentValue</code> returns <code>true</code>.
+     *
+     * In the third case invalid values are truncated to Min and Max
+     * values accordingly. <p>
+     *
+     * The following method tests are to be executed before :
+     * <ul>
+     *  <li> <code> getCurrentValue() </code> </li>
+     * </ul>
+     */
+    public void _setCurrentValue() {
+        executeMethod("getCurrentValue()");
+
+        boolean result = true ;
+        boolean partResult=true;
+        String noMax = "com.sun.star.comp.toolkit.AccessibleScrollBar";
+        String implName = util.utils.getImplName(oObj);
+
+        if (tEnv.getObjRelation("ValueNotPersistent")!=null) {
+            log.println("Excluded since it works like AccessibleAction");
+            tRes.tested("setCurrentValue()",Status.skipped(true));
+            return;
+        }
+
+        if (anotherFromGroup == null) {
+            double newVal = curVal + 1;
+            if (newVal > maxVal) newVal -= 2;
+            if (newVal < minVal) newVal += 1;
+
+            log.println("New value is " + newVal);
+
+            Object setVal = getObjectValue(newVal, val.getClass());
+
+            result &= oObj.setCurrentValue(setVal);
+
+            if (!result) {
+                log.println("The value can't be set");
+                throw new StatusException(Status.skipped(true));
+            }
+
+            double resVal = getDoubleValue(oObj.getCurrentValue());
+            log.println("Res value is " + resVal);
+
+            result &= Math.abs(newVal - resVal) < 0.00001;
+
+            log.println("Checking min/max values");
+            result &= oObj.setCurrentValue(getObjectValue(minVal, val.getClass()));
+            log.println("Setting to "+ getObjectValue(minVal, val.getClass()));
+            resVal = getDoubleValue(oObj.getCurrentValue());
+            log.println("Result min value is " + resVal);
+            result &= Math.abs(minVal - resVal) < 0.00001;
+            log.println("\t works: "+(Math.abs(minVal - resVal) < 0.00001));
+
+            result &= oObj.setCurrentValue(getObjectValue(maxVal, val.getClass()));
+            log.println("Setting to "+ getObjectValue(maxVal, val.getClass()));
+            resVal = getDoubleValue(oObj.getCurrentValue());
+            log.println("Result max value is " + resVal);
+            partResult = Math.abs(maxVal - resVal) < 0.00001;
+
+            if (implName.equals(noMax)) {
+                log.println("If one sets the maximum value of a scroll bar with XScrollBar::setMaximum(),"+
+                "then XScrollBar::getValue() returns the maximum value minus the visible size of"+
+                "the thumb");
+                //using arbitrary Value, since we can't determine the resulting value
+                partResult = resVal > 10;
+            }
+
+            result &=partResult;
+            log.println("\t works: "+partResult);
+
+            log.println("Checking truncating of min/max values");
+            oObj.setCurrentValue(getObjectValue(minVal - 1, val.getClass()));
+            log.println("Setting to "+ getObjectValue(minVal -1 , val.getClass()));
+            resVal = getDoubleValue(oObj.getCurrentValue());
+            log.println("Result min value is " + resVal);
+            result &= Math.abs(minVal - resVal) < 0.00001;
+            log.println("\t works: "+(Math.abs(minVal - resVal) < 0.00001));
+
+            oObj.setCurrentValue(getObjectValue(maxVal + 1, val.getClass()));
+            log.println("Setting to "+ getObjectValue(maxVal +1 , val.getClass()));
+            resVal = getDoubleValue(oObj.getCurrentValue());
+            log.println("Result max value is " + resVal);
+            partResult = Math.abs(maxVal - resVal) < 0.00001;
+            if (implName.equals(noMax)) {
+                log.println("If one sets the maximum value of a scroll bar with XScrollBar::setMaximum(),"+
+                "then XScrollBar::getValue() returns the maximum value minus the visible size of"+
+                "the thumb");
+                //using arbitrary Value, since we can't determine the resulting value
+                partResult = resVal > 10;
+            }
+
+            result &=partResult;
+            log.println("\t works: "+partResult);
+        } else {
+            int curValBase = getIntegerValue(val);
+            Object valAnotherFromGroup = anotherFromGroup.getCurrentValue();
+            int curValAnother = getIntegerValue(valAnotherFromGroup);
+            log.println("Current value of base component: " + curValBase);
+            log.println("Current value of another component from group: " +
+                curValAnother);
+            log.println("Set value of base component to " + curValAnother);
+            if (tEnv.getTestCase().getObjectName().equals("AccessibleRadioButton")) {
+                anotherFromGroup.setCurrentValue(Integer.valueOf(curValBase));
+            } else {
+                oObj.setCurrentValue(valAnotherFromGroup);
+            }
+            log.println("Checking of values...");
+            int newValBase = getIntegerValue(oObj.getCurrentValue());
+            int newValAnother = getIntegerValue(
+                anotherFromGroup.getCurrentValue());
+            log.println("New value of base component: " + newValBase);
+            log.println("Expected value of base component: " + curValAnother);
+            log.println("New value of another component from group: " +
+                newValAnother);
+            log.println("Expected value of another component from group: " +
+                curValBase);
+
+            result = (newValBase == curValAnother) &&
+                (newValAnother == curValBase);
+        }
+
+        tRes.tested("setCurrentValue()", result);
+    }
+
+    /**
+     * Gets and stores maximal value. <p>
+     *
+     * Has <b> OK </b> status if non empty value returned and
+     * Max value is greater than Min value.
+     *
+     * The following method tests are to be completed successfully before :
+     * <ul>
+     *  <li> <code> getMinimumValue() </code> : to compare with </li>
+     * </ul>
+     */
+    public void _getMaximumValue() {
+        requiredMethod("getMinimumValue()");
+
+        boolean result = true ;
+
+        Object val = oObj.getMaximumValue();
+        if (util.utils.isVoid(val)) {
+            maxVal = Double.MAX_VALUE ;
+            result = false;
+        } else {
+            maxVal = getDoubleValue(val);
+        }
+        log.println("Max is " + val.getClass()+ " = " + maxVal);
+
+        result &= maxVal >= minVal;
+
+        tRes.tested("getMaximumValue()", result) ;
+    }
+
+    /**
+     * Gets and stores minimal value. <p>
+     *
+     * Has <b> OK </b> status if non empty value returned. <p>
+     *
+     */
+    public void _getMinimumValue() {
+        boolean result = true ;
+
+        Object val = oObj.getMinimumValue() ;
+        if (util.utils.isVoid(val)) {
+            minVal = - Double.MAX_VALUE ;
+            result = false;
+        } else {
+            minVal = getDoubleValue(val);
+        }
+        log.println("Min is " + val.getClass()+ " = " + minVal);
+
+        tRes.tested("getMinimumValue()", result) ;
+    }
+
+    private int getIntegerValue(Object val) {
+        if (val instanceof Integer) {
+            return ((Integer) val).intValue();
+        } else {
+            throw new StatusException
+                (Status.failed("Unexpected value type: " + val.getClass()));
+        }
+    }
+
+    private double getDoubleValue(Object val) {
+        if (val instanceof Integer) {
+            return ((Integer) val).doubleValue();
+        }
+        else if (val instanceof Short) {
+            return ((Short) val).doubleValue();
+        }
+        else if (val instanceof Float) {
+            return ((Float) val).doubleValue();
+        }
+        else if (val instanceof Double) {
+            return ((Double) val).doubleValue();
+        }
+        else if (util.utils.isVoid(val)) {
+            return Double.NaN;
+        }
+        else {
+            throw new StatusException
+                (Status.failed("Undetected value type: " + val.getClass()));
+        }
+    }
+
+    private Object getObjectValue(double val, Class<?> clazz) {
+        if (clazz.equals(Integer.class)) {
+            return Integer.valueOf((int)val);
+        }
+        else if (clazz.equals(Short.class)) {
+            return Short.valueOf((short)val);
+        }
+        else if (clazz.equals(Float.class)) {
+            return new Float((float)val);
+        }
+        else if (clazz.equals(Double.class)) {
+            return new Double(val);
+        }
+        else {
+            throw new StatusException
+                (Status.failed("Unexpected class: " + clazz));
+        }
+    }
+
+    /**
+     * Disposes test environment.
+     */
+    @Override
+    protected void after() {
+        disposeEnvironment();
+    }
+}