qadevOOo/tests/java/ifc/accessibility/_XAccessibleValue.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 package ifc.accessibility;
  29
  30
  31 import lib.MultiMethodTest;
  32 import lib.Status;
  33 import lib.StatusException;
  34
  35 import com.sun.star.accessibility.XAccessibleValue;
  36
  37 /**
  38  * Testing <code>com.sun.star.accessibility.XAccessibleValue</code>
  39  * interface methods :
  40  * <ul>
  41  *  <li><code> getCurrentValue()</code></li>
  42  *  <li><code> setCurrentValue()</code></li>
  43  *  <li><code> getMaximumValue()</code></li>
  44  *  <li><code> getMinimumValue()</code></li>
  45  * </ul> <p>
  46  *
  47  * This test needs the following object relations :
  48  * <ul>
  49  *  <li> <code>'XAccessibleValue.anotherFromGroup'</code>
  50  *  (of type <code>XAccessibleValue</code>) <b> optional </b>:
  51  *   another component from the group(e.g. radio button group)</li>
  52  *  </ul><p>
  53  * @see com.sun.star.accessibility.XAccessibleValue
  54  */
  55 public class _XAccessibleValue extends MultiMethodTest {
  56
  57     public XAccessibleValue oObj = null;
  58
  59     private double minVal = 0;
  60     private double maxVal = 0;
  61     private double curVal = 0;
  62     private Object val = null;
  63     XAccessibleValue anotherFromGroup = null;
  64
  65     protected void before() {
  66         anotherFromGroup = (XAccessibleValue)tEnv.getObjRelation(
  67             "XAccessibleValue.anotherFromGroup");
  68     }
  69
  70     /**
  71      * Gets current value and stores it as double. <p>
  72      *
  73      * Has <b> OK </b> status if the current value is between Min and Max
  74      * values. <p>
  75      *
  76      * The following method tests are to be executed before :
  77      * <ul>
  78      *  <li> <code> getMaximumValue </code> </li>
  79      *  <li> <code> getMinimumValue </code> </li>
  80      * </ul>
  81      */
  82     public void _getCurrentValue() {
  83         executeMethod("getMaximumValue()");
  84         executeMethod("getMinimumValue()");
  85
  86         boolean result = true;
  87
  88         double curVal ;
  89         val = oObj.getCurrentValue() ;
  90         if (util.utils.isVoid(val)) {
  91             val = new Integer(0);
  92             curVal = 0;
  93         } else  {
  94             curVal = getDoubleValue(val);
  95         }
  96
  97         if (curVal < minVal || maxVal < curVal) {
  98             log.println("" + (curVal - minVal) + "," + (maxVal - curVal));
  99             log.println("Current value " + curVal + " is not in range ["
 100                 + minVal + "," + maxVal + "]");
 101             result = false;
 102         }
 103
 104         tRes.tested("getCurrentValue()", result) ;
 105     }
 106
 107     /**
 108      * Performs testing for following cases :
 109      * <ul>
 110      *  <li> Creates new value in valid range and sets it. </li>
 111      *  <li> Sets maximum and minimum values. </li>
 112      *  <li> Sets Min - 1, and Max + 1 values </li>
 113      * </ul> <p>
 114      *
 115      * Has <b> OK </b> status if for the first case the value returned
 116      * is the same as was set and the method <code>setCurrentValue</code>
 117      * returns <code>true</code>.
 118      *
 119      * In the second if Max and Min values are set and method
 120      * <code>setCurrentValue</code> returns <code>true</code>.
 121      *
 122      * In the third case invalid values are truncated to Min and Max
 123      * values accordingly. <p>
 124      *
 125      * The following method tests are to be executed before :
 126      * <ul>
 127      *  <li> <code> getCurrentValue() </code> </li>
 128      * </ul>
 129      */
 130     public void _setCurrentValue() {
 131         executeMethod("getCurrentValue()");
 132
 133         boolean result = true ;
 134         boolean partResult=true;
 135         String noMax = "com.sun.star.comp.toolkit.AccessibleScrollBar";
 136         String implName = util.utils.getImplName(oObj);
 137
 138         if (tEnv.getObjRelation("ValueNotPersitent")!=null) {
 139             log.println("Excluded since it works like AccessibleAction");
 140             tRes.tested("setCurrentValue()",Status.skipped(true));
 141             return;
 142         }
 143
 144         if (anotherFromGroup == null) {
 145             double newVal = curVal + 1;
 146             if (newVal > maxVal) newVal -= 2;
 147             if (newVal < minVal) newVal += 1;
 148
 149             log.println("New value is " + newVal);
 150
 151             Object setVal = getObjectValue(newVal, val.getClass());
 152
 153             result &= oObj.setCurrentValue(setVal);
 154
 155             if (!result) {
 156                 log.println("The value can't be set");
 157                 throw new StatusException(Status.skipped(true));
 158             }
 159
 160             double resVal = getDoubleValue(oObj.getCurrentValue());
 161             log.println("Res value is " + resVal);
 162
 163             result &= Math.abs(newVal - resVal) < 0.00001;
 164
 165             log.println("Checking min/max values");
 166             result &= oObj.setCurrentValue(getObjectValue(minVal, val.getClass()));
 167             log.println("Setting to "+ getObjectValue(minVal, val.getClass()));
 168             resVal = getDoubleValue(oObj.getCurrentValue());
 169             log.println("Result min value is " + resVal);
 170             result &= Math.abs(minVal - resVal) < 0.00001;
 171             log.println("\t works: "+(Math.abs(minVal - resVal) < 0.00001));
 172
 173             result &= oObj.setCurrentValue(getObjectValue(maxVal, val.getClass()));
 174             log.println("Setting to "+ getObjectValue(maxVal, val.getClass()));
 175             resVal = getDoubleValue(oObj.getCurrentValue());
 176             log.println("Result max value is " + resVal);
 177             partResult = Math.abs(maxVal - resVal) < 0.00001;
 178
 179             if (implName.equals(noMax)) {
 180                 log.println("If one sets the maximum value of a scroll bar with XScrollBar::setMaximum(),"+
 181                 "then XScrollBar::getValue() returns the maximum value minus the visible size of"+
 182                 "the thumb");
 183                 //using abitrary Value, since we can't determine the resulting value
 184                 partResult = resVal > 10;
 185             }
 186
 187             result &=partResult;
 188             log.println("\t works: "+partResult);
 189
 190             log.println("Checking truncating of min/max values");
 191             oObj.setCurrentValue(getObjectValue(minVal - 1, val.getClass()));
 192             log.println("Setting to "+ getObjectValue(minVal -1 , val.getClass()));
 193             resVal = getDoubleValue(oObj.getCurrentValue());
 194             log.println("Result min value is " + resVal);
 195             result &= Math.abs(minVal - resVal) < 0.00001;
 196             log.println("\t works: "+(Math.abs(minVal - resVal) < 0.00001));
 197
 198             oObj.setCurrentValue(getObjectValue(maxVal + 1, val.getClass()));
 199             log.println("Setting to "+ getObjectValue(maxVal +1 , val.getClass()));
 200             resVal = getDoubleValue(oObj.getCurrentValue());
 201             log.println("Result max value is " + resVal);
 202             partResult = Math.abs(maxVal - resVal) < 0.00001;
 203             if (implName.equals(noMax)) {
 204                 log.println("If one sets the maximum value of a scroll bar with XScrollBar::setMaximum(),"+
 205                 "then XScrollBar::getValue() returns the maximum value minus the visible size of"+
 206                 "the thumb");
 207                 //using abitrary Value, since we can't determine the resulting value
 208                 partResult = resVal > 10;
 209             }
 210
 211             result &=partResult;
 212             log.println("\t works: "+partResult);
 213         } else {
 214             int curValBase = getIntegerValue(val);
 215             Object valAnotherFromGroup = anotherFromGroup.getCurrentValue();
 216             int curValAnother = getIntegerValue(valAnotherFromGroup);
 217             log.println("Current value of base component: " + curValBase);
 218             log.println("Current value of another component from group: " +
 219                 curValAnother);
 220             log.println("Set value of base component to " + curValAnother);
 221             if (tEnv.getTestCase().getObjectName().equals("AccessibleRadioButton")) {
 222                 anotherFromGroup.setCurrentValue(new Integer(curValBase));
 223             } else {
 224                 oObj.setCurrentValue(valAnotherFromGroup);
 225             }
 226             log.println("Checking of values...");
 227             int newValBase = getIntegerValue(oObj.getCurrentValue());
 228             int newValAnother = getIntegerValue(
 229                 anotherFromGroup.getCurrentValue());
 230             log.println("New value of base component: " + newValBase);
 231             log.println("Expected value of base component: " + curValAnother);
 232             log.println("New value of another component from group: " +
 233                 newValAnother);
 234             log.println("Expected value of another component from group: " +
 235                 curValBase);
 236
 237             result = (newValBase == curValAnother) &&
 238                 (newValAnother == curValBase);
 239         }
 240
 241         tRes.tested("setCurrentValue()", result);
 242     }
 243
 244     /**
 245      * Gets and stores maximal value. <p>
 246      *
 247      * Has <b> OK </b> status if non empty value returned and
 248      * Max value is greater than Min value.
 249      *
 250      * The following method tests are to be completed successfully before :
 251      * <ul>
 252      *  <li> <code> getMinimumValue() </code> : to compare with </li>
 253      * </ul>
 254      */
 255     public void _getMaximumValue() {
 256         requiredMethod("getMinimumValue()");
 257
 258         boolean result = true ;
 259
 260         Object val = oObj.getMaximumValue();
 261         if (util.utils.isVoid(val)) {
 262             maxVal = Double.MAX_VALUE ;
 263             result = false;
 264         } else {
 265             maxVal = getDoubleValue(val);
 266         }
 267         log.println("Max is " + val.getClass()+ " = " + maxVal);
 268
 269         result &= maxVal >= minVal;
 270
 271         tRes.tested("getMaximumValue()", result) ;
 272     }
 273
 274     /**
 275      * Gets and stores minimal value. <p>
 276      *
 277      * Has <b> OK </b> status if non empty value returned. <p>
 278      *
 279      */
 280     public void _getMinimumValue() {
 281         boolean result = true ;
 282
 283         Object val = oObj.getMinimumValue() ;
 284         if (util.utils.isVoid(val)) {
 285             minVal = - Double.MAX_VALUE ;
 286             result = false;
 287         } else {
 288             minVal = getDoubleValue(val);
 289         }
 290         log.println("Min is " + val.getClass()+ " = " + minVal);
 291
 292         tRes.tested("getMinimumValue()", result) ;
 293     }
 294
 295     private int getIntegerValue(Object val) {
 296         if (val instanceof Integer) {
 297             return ((Integer) val).intValue();
 298         } else {
 299             throw new StatusException
 300                 (Status.failed("Unexpected value type: " + val.getClass()));
 301         }
 302     }
 303
 304     private double getDoubleValue(Object val) {
 305         if (val instanceof Integer) {
 306             return ((Integer) val).doubleValue();
 307         }
 308         else if (val instanceof Short) {
 309             return ((Short) val).doubleValue();
 310         }
 311         else if (val instanceof Float) {
 312             return ((Float) val).doubleValue();
 313         }
 314         else if (val instanceof Double) {
 315             return ((Double) val).doubleValue();
 316         }
 317         else if (util.utils.isVoid(val)) {
 318             return Double.NaN;
 319         }
 320         else {
 321             throw new StatusException
 322                 (Status.failed("Undetected value type: " + val.getClass()));
 323         }
 324     }
 325
 326     private Object getObjectValue(double val, Class clazz) {
 327         if (clazz.equals(Integer.class)) {
 328             return new Integer((int)val);
 329         }
 330         else if (clazz.equals(Short.class)) {
 331             return new Short((short)val);
 332         }
 333         else if (clazz.equals(Float.class)) {
 334             return new Float((float)val);
 335         }
 336         else if (clazz.equals(Double.class)) {
 337             return new Double(val);
 338         }
 339         else {
 340             throw new StatusException
 341                 (Status.failed("Unexpected class: " + clazz));
 342         }
 343     }
 344
 345     /**
 346      * Disposes test environment.
 347      */
 348     protected void after() {
 349         disposeEnvironment();
 350     }
 351 }