qadevOOo/tests/java/ifc/beans/_XTolerantMultiPropertySet.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 package ifc.beans;
  28
  29 import com.sun.star.beans.GetDirectPropertyTolerantResult;
  30 import com.sun.star.beans.GetPropertyTolerantResult;
  31 import com.sun.star.beans.Property;
  32 import com.sun.star.beans.PropertyAttribute;
  33 import com.sun.star.beans.PropertyState;
  34 import com.sun.star.beans.SetPropertyTolerantFailed;
  35 import com.sun.star.beans.XPropertySet;
  36 import com.sun.star.beans.XPropertyState;
  37 import com.sun.star.beans.XTolerantMultiPropertySet;
  38 import com.sun.star.uno.UnoRuntime;
  39
  40 import java.util.ArrayList;
  41 import java.util.Collections;
  42
  43 import lib.MultiMethodTest;
  44 import lib.Status;
  45 import lib.StatusException;
  46
  47 import util.ValueChanger;
  48 import util.ValueComparer;
  49
  50
  51 public class _XTolerantMultiPropertySet extends MultiMethodTest {
  52     public XTolerantMultiPropertySet oObj;
  53     protected String[] namesOfDirectProperties = null;
  54     protected String[] namesOfProperties = null;
  55     protected Object[] valuesOfProperties = null;
  56     protected Property[] properties = null;
  57     protected XPropertyState pState = null;
  58     protected XPropertySet PS = null;
  59
  60
  61     /*
  62      * Queries XPropertySet from the given Component and gets XPropertySetInfo
  63      * from it to get the PropertyNames available and their Values<br>
  64      * Then queries XPropertyState from the given Component
  65      * to get the direct properties<br>
  66      * Throws a lib StatusException if the Component doesn't support XPropertySet or XPropertyState
  67      */
  68     public void before() {
  69         PS = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,
  70                                                       tEnv.getTestObject());
  71
  72         if (PS == null) {
  73             throw new StatusException(Status.failed(
  74                                               "Component doesn't provide the needed XPropertySet"));
  75         }
  76
  77         pState = (XPropertyState) UnoRuntime.queryInterface(
  78                          XPropertyState.class, tEnv.getTestObject());
  79
  80         if (pState == null) {
  81             throw new StatusException(Status.failed(
  82                                               "Component doesn't provide the needed XPropertyState"));
  83         }
  84
  85         properties = PS.getPropertySetInfo().getProperties();
  86         namesOfProperties = getProperties();
  87         valuesOfProperties = getPropertyValues(namesOfProperties);
  88     }
  89
  90     /*
  91      * Calls the method getDirectPropertyValuesTolerant() and compares the resulting
  92      * sequence with the one gained as direct values in the before() method.<br>
  93      * Has OK state if both sequences equal.
  94      */
  95     public void _getDirectPropertyValuesTolerant() {
  96         namesOfDirectProperties = getDirectProperties(properties);
  97
  98         GetDirectPropertyTolerantResult[] GDPR = oObj.getDirectPropertyValuesTolerant(
  99                                                          namesOfProperties);
 100
 101         boolean res = (GDPR.length == namesOfDirectProperties.length);
 102
 103         if (!res) {
 104             log.println("Found: ");
 105
 106             for (int i = 0; i < GDPR.length; i++) {
 107                 log.println("\t" + GDPR[i].Name);
 108             }
 109
 110             log.println("Expected: ");
 111
 112             for (int i = 0; i < namesOfDirectProperties.length; i++) {
 113                 log.println("\t" + namesOfDirectProperties[i]);
 114             }
 115         } else {
 116             for (int i = 0; i < GDPR.length; i++) {
 117                 boolean localres = GDPR[i].Name.equals(
 118                                            namesOfDirectProperties[i]);
 119
 120                 if (!localres) {
 121                     log.println("Found: ");
 122                     log.println("\t" + GDPR[i].Name);
 123                     log.println("Expected: ");
 124                     log.println("\t" + namesOfDirectProperties[i]);
 125                 }
 126
 127                 res &= localres;
 128             }
 129         }
 130
 131         tRes.tested("getDirectPropertyValuesTolerant()", res);
 132     }
 133
 134     public void _getPropertyValuesTolerant() {
 135         requiredMethod("getDirectPropertyValuesTolerant()");
 136         GetPropertyTolerantResult[] GPR = oObj.getPropertyValuesTolerant(
 137                                                   namesOfProperties);
 138
 139         boolean res = (GPR.length == namesOfProperties.length);
 140
 141         if (!res) {
 142             log.println("Length of sequences differs");
 143             log.println("Found: " + GPR.length);
 144             log.println("Expected: " + namesOfProperties.length);
 145         } else {
 146             for (int i = 0; i < GPR.length; i++) {
 147                 boolean localres = true;
 148
 149                 if (!(GPR[i].Value instanceof com.sun.star.uno.Any)) {
 150                     localres = ValueComparer.equalValue(GPR[i].Value,
 151                                                         valuesOfProperties[i]);
 152
 153                 }
 154
 155                 if (!localres) {
 156                     log.println("Values differ for : " +
 157                                 namesOfProperties[i]);
 158                     log.println("\t" + GPR[i].Value);
 159                     log.println("Expected: ");
 160                     log.println("\t" + valuesOfProperties[i]);
 161                 }
 162
 163                 res &= localres;
 164             }
 165         }
 166
 167         tRes.tested("getPropertyValuesTolerant()", res);
 168     }
 169
 170     public void _setPropertyValuesTolerant() {
 171         requiredMethod("getPropertyValuesTolerant()");
 172
 173         SetPropertyTolerantFailed[] SPTF = null;
 174
 175         try {
 176             SPTF = oObj.setPropertyValuesTolerant(namesOfProperties,
 177                                                   getNewValues(
 178                                                           valuesOfProperties));
 179         } catch (com.sun.star.lang.IllegalArgumentException e) {
 180             e.printStackTrace(log);
 181         }
 182
 183         //read only properties will throw a PropertyVetoExeption if they are set
 184         int failures = 0;
 185
 186         for (int k = 0; k < SPTF.length; k++) {
 187             if (SPTF[k].Result == com.sun.star.beans.TolerantPropertySetResultType.PROPERTY_VETO) {
 188                 failures++;
 189             }
 190         }
 191
 192         int roProps = getCountOfReadOnlyProperties();
 193
 194         boolean res = (failures == roProps);
 195
 196         if (!res) {
 197             log.println("Failures: " + failures);
 198             log.println("Count of R/O properties: " + roProps);
 199
 200             for (int i = 0; i < SPTF.length; i++) {
 201                 if (SPTF[i].Result == com.sun.star.beans.TolerantPropertySetResultType.PROPERTY_VETO) {
 202                     failures++;
 203                     log.println("Failed for " + SPTF[i].Name);
 204                     log.println("\t Result: " + SPTF[i].Result);
 205                 }
 206             }
 207         } else {
 208             for (int i = 0; i < SPTF.length; i++) {
 209                 boolean localres = true;
 210                 GetPropertyTolerantResult[] GPR = oObj.getPropertyValuesTolerant(
 211                                                           namesOfProperties);
 212
 213                 if ((!(GPR[i].Value instanceof com.sun.star.uno.Any)) &&
 214                         (SPTF[i].Result == com.sun.star.beans.TolerantPropertySetResultType.SUCCESS)) {
 215                     localres = ValueComparer.equalValue(GPR[i].Value,
 216                                                         valuesOfProperties[i]);
 217                 }
 218
 219                 if (!localres) {
 220                     log.println("Values differ for : " +
 221                                 namesOfProperties[i]);
 222                     log.println("\t" + GPR[i].Value);
 223                     log.println("Expected: ");
 224                     log.println("\t" + valuesOfProperties[i]);
 225                 }
 226
 227                 res &= localres;
 228             }
 229         }
 230
 231         tRes.tested("setPropertyValuesTolerant()", res);
 232     }
 233
 234     /*
 235      * This method returns a sorted list of property names
 236      * contained in a given sequence of properties that additionally
 237      * have the state DIRECT_VALUE
 238      */
 239     protected String[] getDirectProperties(Property[] props) {
 240         ArrayList direct = new ArrayList();
 241
 242         for (int i = 0; i < props.length; i++) {
 243             String pName = props[i].Name;
 244
 245             try {
 246                 PropertyState state = pState.getPropertyState(pName);
 247
 248                 if (state.equals(PropertyState.DIRECT_VALUE)) {
 249                     if (isUsable(pName)) direct.add(pName);
 250                 }
 251             } catch (com.sun.star.beans.UnknownPropertyException e) {
 252                 log.println("Property '" + pName + "'");
 253             }
 254         }
 255
 256         Collections.sort(direct);
 257
 258         Object[] obj = direct.toArray();
 259         String[] ret = new String[obj.length];
 260
 261         for (int i = 0; i < obj.length; i++) {
 262             ret[i] = (String) obj[i];
 263         }
 264
 265         return ret;
 266     }
 267
 268     private boolean isUsable(String name) {
 269         boolean isUsable=true;
 270         if (name.startsWith("TextWriting")) isUsable = false;
 271         if (name.startsWith("MetaFile")) isUsable = false;
 272         return isUsable;
 273     }
 274
 275     /*
 276      * This method returns a sorted list of property names
 277      * contained in a given sequence of properties
 278      */
 279     protected String[] getProperties() {
 280         ArrayList names = new ArrayList();
 281
 282         for (int i = 0; i < properties.length; i++) {
 283             String pName = properties[i].Name;
 284             if (isUsable(pName)) names.add(pName);
 285         }
 286
 287         Collections.sort(names);
 288
 289         Object[] obj = names.toArray();
 290         String[] ret = new String[obj.length];
 291
 292         for (int i = 0; i < obj.length; i++) {
 293             ret[i] = (String) obj[i];
 294         }
 295
 296         return ret;
 297     }
 298
 299     /*
 300      * Returns the values of a given array of properties in an Object array
 301      */
 302     protected Object[] getPropertyValues(String[] propertyNames) {
 303         Object[] values = new Object[propertyNames.length];
 304
 305         for (int i = 0; i < propertyNames.length; i++) {
 306             try {
 307                 values[i] = PS.getPropertyValue(propertyNames[i]);
 308             } catch (com.sun.star.beans.UnknownPropertyException e) {
 309                 e.printStackTrace(log);
 310             } catch (com.sun.star.lang.WrappedTargetException e) {
 311                 e.printStackTrace(log);
 312             }
 313         }
 314
 315         return values;
 316     }
 317
 318     protected int getCountOfReadOnlyProperties() {
 319         int ro = 0;
 320
 321         for (int i = 0; i < properties.length; i++) {
 322             Property property = properties[i];
 323             boolean isWritable = ((property.Attributes & PropertyAttribute.READONLY) == 0);
 324
 325             if (!isWritable) {
 326                 ro++;
 327             }
 328         }
 329
 330         return ro;
 331     }
 332
 333     protected Object[] getNewValues(Object[] oldValues) {
 334         Object[] newValues = new Object[oldValues.length];
 335
 336         for (int i = 0; i < oldValues.length; i++) {
 337             if (oldValues[i] instanceof com.sun.star.uno.Any) {
 338                 newValues[i] = oldValues[i];
 339             } else {
 340                 newValues[i] = ValueChanger.changePValue(oldValues[i]);
 341             }
 342         }
 343
 344         return newValues;
 345     }
 346 }