sc/qa/complex/dataPilot/_XPropertySet.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package complex.dataPilot;
  20
  21 import com.sun.star.beans.Property;
  22 import com.sun.star.beans.PropertyAttribute;
  23 import com.sun.star.beans.PropertyChangeEvent;
  24 import com.sun.star.beans.XPropertyChangeListener;
  25 import com.sun.star.beans.XPropertySet;
  26 import com.sun.star.beans.XPropertySetInfo;
  27 import com.sun.star.beans.XVetoableChangeListener;
  28 import com.sun.star.lang.EventObject;
  29 import java.util.Random;
  30 import java.util.StringTokenizer;
  31 import lib.TestParameters;
  32 import util.ValueChanger;
  33 import util.utils;
  34
  35 /**
  36 * Testing <code>com.sun.star.beans.XPropertySet</code>
  37 * interface methods :
  38 * <ul>
  39 *  <li><code>getPropertySetInfo()</code></li>
  40 *  <li><code>setPropertyValue()</code></li>
  41 *  <li><code>getPropertyValue()</code></li>
  42 *  <li><code>addPropertyChangeListener()</code></li>
  43 *  <li><code>removePropertyChangeListener()</code></li>
  44 *  <li><code>addVetoableChangeListener()</code></li>
  45 *  <li><code>removeVetoableChangeListener()</code></li>
  46 * </ul>
  47 * @see com.sun.star.beans.XPropertySet
  48 */
  49 public class _XPropertySet {
  50
  51     /**
  52      * The object that is testsed.
  53      */
  54     private final XPropertySet oObj;
  55
  56     /**
  57      * The test parameters
  58      */
  59     private final TestParameters param;
  60
  61     /**
  62     * Flag that indicates change listener was called.
  63     */
  64     private boolean propertyChanged = false;
  65
  66
  67     /**
  68      * The own property change listener
  69      */
  70     private final XPropertyChangeListener PClistener = new MyChangeListener();
  71
  72     /**
  73     * Listener that must be called on bound property changing.
  74     */
  75     private class MyChangeListener implements XPropertyChangeListener {
  76          /**
  77          * Just set <code>propertyChanged</code> flag to true.
  78          */
  79          public void propertyChange(PropertyChangeEvent e) {
  80             propertyChanged = true;
  81          }
  82          public void disposing (EventObject obj) {}
  83     }
  84
  85
  86     /**
  87     * Flag that indicates veto listener was called.
  88     */
  89     private boolean vetoableChanged = false;
  90
  91     /**
  92      * The own vetoable change listener
  93      */
  94     private final XVetoableChangeListener VClistener = new MyVetoListener();
  95
  96     /**
  97     * Listener that must be called on constrained property changing.
  98     */
  99     private class MyVetoListener implements XVetoableChangeListener {
 100          /**
 101          * Just set <code>vetoableChanged</code> flag to true.
 102          */
 103          public void vetoableChange(PropertyChangeEvent e) {
 104             vetoableChanged = true;
 105          }
 106          public void disposing (EventObject obj) {}
 107     }
 108
 109
 110     /**
 111      * Properties to test
 112      */
 113     private final PropsToTest PTT = new PropsToTest();
 114
 115     /**
 116     * Structure that collects three properties of each type to test :
 117     * Constrained, Bound and Normal.
 118     */
 119     private class PropsToTest {
 120            private String constrained = null;
 121            private String bound = null;
 122            String normal = null;
 123     }
 124
 125     /**
 126      * Constructor: gets the object to test, a logger and the test parameters
 127      * @param xObj The test object
 128      * @param param The test parameters
 129      */
 130     public _XPropertySet(XPropertySet xObj/*, LogWriter log*/, TestParameters param) {
 131         oObj = xObj;
 132         // this.log = log;
 133         this.param = param;
 134     }
 135
 136     /**
 137     * Tests method <code>getPropertySetInfo</code>. After test completed
 138     * call {@link #getPropsToTest} method to retrieve different kinds
 139     * of properties to test then. <p>
 140     * Has OK status if not null <code>XPropertySetInfo</code>
 141     * object returned.<p>
 142     * Since <code>getPropertySetInfo</code> is optional, it may return null,
 143     * if it is not implemented. This method uses then an object relation
 144     * <code>PTT</code> (Properties To Test) to determine available properties.
 145     * All tests for services without <code>getPropertySetInfo</code> must
 146     * provide this object relation.
 147     */
 148     public boolean _getPropertySetInfo() {
 149         XPropertySetInfo propertySetInfo = oObj.getPropertySetInfo();
 150
 151         if (propertySetInfo == null) {
 152             System.out.println("getPropertySetInfo() method returned null");
 153             String[] ptt = (String[]) param.get("PTT");
 154             PTT.normal=ptt[0];
 155             PTT.bound=ptt[1];
 156             PTT.constrained=ptt[2];
 157         } else {
 158             getPropsToTest(propertySetInfo);
 159         }
 160
 161         return true;
 162
 163     } // end of getPropertySetInfo()
 164
 165     /**
 166     * Tests change listener which added for bound properties.
 167     * Adds listener to bound property (if it exists), then changes
 168     * its value and check if listener was called. <p>
 169     * Method tests to be successfully completed before :
 170     * <ul>
 171     *  <li> <code>getPropertySetInfo</code> : in this method test
 172     *    one of bound properties is retrieved. </li>
 173     * </ul> <p>
 174     * Has OK status if NO bound properties exist or if listener
 175     * was successfully called.
 176     */
 177     public boolean _addPropertyChangeListener() {
 178
 179         propertyChanged = false;
 180         boolean result = true;
 181
 182         if ( PTT.bound.equals("none") ) {
 183             System.out.println("*** No bound properties found ***");
 184         } else {
 185             try {
 186                 oObj.addPropertyChangeListener(PTT.bound,PClistener);
 187                 Object gValue = oObj.getPropertyValue(PTT.bound);
 188                 oObj.setPropertyValue(PTT.bound,
 189                     ValueChanger.changePValue(gValue));
 190             } catch (com.sun.star.beans.PropertyVetoException e) {
 191                 System.out.println("Exception occurred while trying to change "+
 192                     "property '"+ PTT.bound+"'");
 193                 e.printStackTrace();
 194             } catch (com.sun.star.lang.IllegalArgumentException e) {
 195                 System.out.println("Exception occurred while trying to change "+
 196                     "property '"+ PTT.bound+"'");
 197                 e.printStackTrace();
 198             } catch (com.sun.star.beans.UnknownPropertyException e) {
 199                 System.out.println("Exception occurred while trying to change "+
 200                     "property '"+ PTT.bound+"'");
 201                 e.printStackTrace();
 202             } catch (com.sun.star.lang.WrappedTargetException e) {
 203                 System.out.println("Exception occurred while trying to change "+
 204                     "property '"+ PTT.bound+"'");
 205                 e.printStackTrace();
 206             } // end of try-catch
 207             result = propertyChanged;
 208             if (!propertyChanged) {
 209                 System.out.println("propertyChangeListener wasn't called for '"+
 210                     PTT.bound+"'");
 211             }
 212         } //endif
 213
 214         return result;
 215
 216     } // end of addPropertyChangeListener()
 217
 218     /**
 219     * Tests vetoable listener which added for constrained properties.
 220     * Adds listener to constrained property (if it exists), then changes
 221     * its value and check if listener was called. <p>
 222     * Method tests to be successfully completed before :
 223     * <ul>
 224     *  <li> <code>getPropertySetInfo</code> : in this method test
 225     *    one of constrained properties is retrieved. </li>
 226     * </ul> <p>
 227     * Has OK status if NO constrained properties exist or if listener
 228     * was successfully called.
 229     */
 230     public boolean _addVetoableChangeListener() {
 231
 232         vetoableChanged = false;
 233         boolean result = true;
 234
 235         if ( PTT.constrained.equals("none") ) {
 236             System.out.println("*** No constrained properties found ***");
 237         } else {
 238             try {
 239                 oObj.addVetoableChangeListener(PTT.constrained,VClistener);
 240                 Object gValue = oObj.getPropertyValue(PTT.constrained);
 241                 oObj.setPropertyValue(PTT.constrained,
 242                     ValueChanger.changePValue(gValue));
 243             } catch (com.sun.star.beans.PropertyVetoException e) {
 244                 System.out.println("Exception occurred while trying to change "+
 245                     "property '"+ PTT.constrained+"'");
 246                 e.printStackTrace();
 247             } catch (com.sun.star.lang.IllegalArgumentException e) {
 248                 System.out.println("Exception occurred while trying to change "+
 249                     "property '"+ PTT.constrained+"'");
 250                 e.printStackTrace();
 251             } catch (com.sun.star.beans.UnknownPropertyException e) {
 252                 System.out.println("Exception occurred while trying to change "+
 253                     "property '"+ PTT.constrained+"'");
 254                 e.printStackTrace();
 255             } catch (com.sun.star.lang.WrappedTargetException e) {
 256                 System.out.println("Exception occurred while trying to change "+
 257                     "property '"+ PTT.constrained+"'");
 258                 e.printStackTrace();
 259             } // end of try-catch
 260             result = vetoableChanged;
 261             if (!vetoableChanged) {
 262                 System.out.println("vetoableChangeListener wasn't called for '"+
 263                     PTT.constrained+"'");
 264             }
 265         } //endif
 266
 267         return result;
 268
 269     } // end of addVetoableChangeListener()
 270
 271
 272     /**
 273     * Tests <code>setPropertyValue</code> method.
 274     * Stores value before call, and compares it with value after
 275     * call. <p>
 276     * Method tests to be successfully completed before :
 277     * <ul>
 278     *  <li> <code>getPropertySetInfo</code> : in this method test
 279     *    one of normal properties is retrieved. </li>
 280     * </ul> <p>
 281     * Has OK status if NO normal properties exist or if value before
 282     * method call is not equal to value after.
 283     */
 284     public boolean _setPropertyValue() {
 285
 286         Object gValue = null;
 287         Object sValue = null;
 288
 289         boolean result = true;
 290
 291         if ( PTT.normal.equals("none") ) {
 292             System.out.println("*** No changeable properties found ***");
 293         } else {
 294             try {
 295                 gValue = oObj.getPropertyValue(PTT.normal);
 296                 sValue = ValueChanger.changePValue(gValue);
 297                 oObj.setPropertyValue(PTT.normal, sValue);
 298                 sValue = oObj.getPropertyValue(PTT.normal);
 299             } catch (com.sun.star.beans.PropertyVetoException e) {
 300                 System.out.println("Exception occurred while trying to change "+
 301                     "property '"+ PTT.normal+"'");
 302                 e.printStackTrace();
 303             } catch (com.sun.star.lang.IllegalArgumentException e) {
 304                 System.out.println("Exception occurred while trying to change "+
 305                     "property '"+ PTT.normal+"'");
 306                 e.printStackTrace();
 307             } catch (com.sun.star.beans.UnknownPropertyException e) {
 308                 System.out.println("Exception occurred while trying to change "+
 309                     "property '"+ PTT.normal+"'");
 310                 e.printStackTrace();
 311             } catch (com.sun.star.lang.WrappedTargetException e) {
 312                 System.out.println("Exception occurred while trying to change "+
 313                     "property '"+ PTT.normal+"'");
 314                 e.printStackTrace();
 315             } // end of try-catch
 316             result = !gValue.equals(sValue);
 317         } //endif
 318
 319         return result;
 320
 321     } // end of setPropertyValue()
 322
 323     /**
 324     * Tests <code>getPropertyValue</code> method.
 325     * Just call this method and checks for no exceptions <p>
 326     * Method tests to be successfully completed before :
 327     * <ul>
 328     *  <li> <code>getPropertySetInfo</code> : in this method test
 329     *    one of normal properties is retrieved. </li>
 330     * </ul> <p>
 331     * Has OK status if NO normal properties exist or if no
 332     * exceptions were thrown.
 333     */
 334     public boolean _getPropertyValue() {
 335
 336         boolean result = true;
 337         String toCheck = PTT.normal;
 338
 339         if ( PTT.normal.equals("none") ) {
 340             toCheck = oObj.getPropertySetInfo().getProperties()[0].Name;
 341             System.out.println("All properties are Read Only");
 342             System.out.println("Using: "+toCheck);
 343         }
 344
 345         try {
 346             oObj.getPropertyValue(toCheck);
 347         } catch (com.sun.star.beans.UnknownPropertyException e) {
 348             System.out.println("Exception occurred while trying to get property '"+
 349                  PTT.normal+"'");
 350             e.printStackTrace();
 351             result = false;
 352         } catch (com.sun.star.lang.WrappedTargetException e) {
 353             System.out.println("Exception occurred while trying to get property '"+
 354                 PTT.normal+"'");
 355             e.printStackTrace();
 356             result = false;
 357         } // end of try-catch
 358
 359         return result;
 360     }
 361
 362     /**
 363     * Tests <code>removePropertyChangeListener</code> method.
 364     * Removes change listener, then changes bound property value
 365     * and checks if the listener was NOT called.
 366     * Method tests to be successfully completed before :
 367     * <ul>
 368     *  <li> <code>addPropertyChangeListener</code> : here listener
 369     *   was added. </li>
 370     * </ul> <p>
 371     * Has OK status if NO bound properties exist or if listener
 372     * was not called and no exceptions arose.
 373     */
 374     public boolean _removePropertyChangeListener() {
 375
 376         propertyChanged = false;
 377         boolean result = true;
 378
 379         if ( PTT.bound.equals("none") ) {
 380             System.out.println("*** No bound properties found ***");
 381         } else {
 382             try {
 383                 propertyChanged = false;
 384                 oObj.removePropertyChangeListener(PTT.bound,PClistener);
 385                 Object gValue = oObj.getPropertyValue(PTT.bound);
 386                 oObj.setPropertyValue(PTT.bound,
 387                     ValueChanger.changePValue(gValue));
 388             } catch (com.sun.star.beans.PropertyVetoException e) {
 389                 System.out.println("Exception occurred while trying to change "+
 390                     "property '"+ PTT.bound+"'");
 391                 e.printStackTrace();
 392             } catch (com.sun.star.lang.IllegalArgumentException e) {
 393                 System.out.println("Exception occurred while trying to change "+
 394                     "property '"+ PTT.bound+"'");
 395                 e.printStackTrace();
 396             } catch (com.sun.star.beans.UnknownPropertyException e) {
 397                 System.out.println("Exception occurred while trying to change "+
 398                     "property '"+ PTT.bound+"'");
 399                 e.printStackTrace();
 400             } catch (com.sun.star.lang.WrappedTargetException e) {
 401                 System.out.println("Exception occurred while trying to change "+
 402                     "property '"+ PTT.bound+"'");
 403                 e.printStackTrace();
 404             } // end of try-catch
 405
 406              result = !propertyChanged;
 407             if (propertyChanged) {
 408                 System.out.println("propertyChangeListener was called after removing"+
 409                     " for '"+PTT.bound+"'");
 410             }
 411         } //endif
 412
 413         return result;
 414
 415     } // end of removePropertyChangeListener()
 416
 417
 418     /**
 419     * Tests <code>removeVetoableChangeListener</code> method.
 420     * Removes vetoable listener, then changes constrained property value
 421     * and checks if the listener was NOT called.
 422     * Method tests to be successfully completed before :
 423     * <ul>
 424     *  <li> <code>addPropertyChangeListener</code> : here vetoable listener
 425     *   was added. </li>
 426     * </ul> <p>
 427     * Has OK status if NO constrained properties exist or if listener
 428     * was NOT called and no exceptions arose.
 429     */
 430     public boolean _removeVetoableChangeListener() {
 431
 432         vetoableChanged = false;
 433         boolean result = true;
 434
 435         if ( PTT.constrained.equals("none") ) {
 436             System.out.println("*** No constrained properties found ***");
 437         } else {
 438             try {
 439                 oObj.removeVetoableChangeListener(PTT.constrained,VClistener);
 440                 Object gValue = oObj.getPropertyValue(PTT.constrained);
 441                 oObj.setPropertyValue(PTT.constrained,
 442                     ValueChanger.changePValue(gValue));
 443             } catch (com.sun.star.beans.PropertyVetoException e) {
 444                 System.out.println("Exception occurred while trying to change "+
 445                     "property '"+ PTT.constrained+"'");
 446                 e.printStackTrace();
 447             } catch (com.sun.star.lang.IllegalArgumentException e) {
 448                 System.out.println("Exception occurred while trying to change "+
 449                     "property '"+ PTT.constrained+"'");
 450                 e.printStackTrace();
 451             } catch (com.sun.star.beans.UnknownPropertyException e) {
 452                 System.out.println("Exception occurred while trying to change "+
 453                     "property '"+ PTT.constrained+"'");
 454                 e.printStackTrace();
 455             } catch (com.sun.star.lang.WrappedTargetException e) {
 456                 System.out.println("Exception occurred while trying to change "+
 457                     "property '"+ PTT.constrained+"'");
 458                 e.printStackTrace();
 459             } // end of try-catch
 460
 461             result = !vetoableChanged;
 462             if (vetoableChanged) {
 463                 System.out.println("vetoableChangeListener was called after "+
 464                     "removing for '"+PTT.constrained+"'");
 465             }
 466         } //endif
 467
 468         return result;
 469
 470     } // end of removeVetoableChangeListener()
 471
 472
 473     /**
 474     * Gets the properties being tested. Searches and stores by one
 475     * property of each kind (Bound, Vetoable, Normal).
 476     */
 477     private PropsToTest getPropsToTest(XPropertySetInfo xPSI) {
 478
 479         Property[] properties = xPSI.getProperties();
 480         String bound = "";
 481         String constrained = "";
 482         String normal = "";
 483
 484         for (int i = 0; i < properties.length; i++) {
 485
 486             Property property = properties[i];
 487             String name = property.Name;
 488             System.out.println("Checking '"+name+"'");
 489             boolean isWritable = ((property.Attributes &
 490                 PropertyAttribute.READONLY) == 0);
 491             boolean isNotNull = ((property.Attributes &
 492                 PropertyAttribute.MAYBEVOID) == 0);
 493             boolean isBound = ((property.Attributes &
 494                 PropertyAttribute.BOUND) != 0);
 495             boolean isConstr = ((property.Attributes &
 496                 PropertyAttribute.CONSTRAINED) != 0);
 497             boolean canChange = false;
 498
 499             if ( !isWritable ) System.out.println("Property '"+name+"' is READONLY");
 500
 501             if (name.endsWith("URL")) isWritable = false;
 502             if (name.startsWith("Fill")) isWritable = false;
 503             if (name.startsWith("Font")) isWritable = false;
 504             if (name.startsWith("IsNumbering")) isWritable = false;
 505             if (name.startsWith("LayerName")) isWritable = false;
 506             if (name.startsWith("Line")) isWritable = false;
 507
 508             if ( isWritable && isNotNull ) canChange = isChangeable(name);
 509
 510             if ( isWritable && isNotNull && isBound && canChange) {
 511                 bound+=name+";";
 512             }
 513
 514             if ( isWritable && isNotNull && isConstr && canChange) {
 515                 constrained+=name+";";
 516             }
 517
 518             if ( isWritable && isNotNull && canChange) normal+=name+";";
 519
 520
 521         } // endfor
 522
 523         //get a random bound property
 524         PTT.bound=getRandomString(bound);
 525         System.out.println("Bound: "+PTT.bound);
 526
 527         //get a random constrained property
 528         PTT.constrained=getRandomString(constrained);
 529         System.out.println("Constrained: "+PTT.constrained);
 530
 531         //get a random normal property
 532         PTT.normal=getRandomString(normal);
 533
 534         return PTT;
 535
 536     }
 537
 538     /**
 539     * Retrieves one random property name from list (property names separated
 540     * by ';') of property names.
 541     */
 542     private String getRandomString(String str) {
 543
 544         String gRS = "none";
 545         Random rnd = new Random();
 546
 547         if (str.equals("")) str = "none";
 548         StringTokenizer ST=new StringTokenizer(str,";");
 549         int nr = rnd.nextInt(ST.countTokens());
 550         if (nr < 1) nr+=1;
 551         for (int i=1; i<nr+1; i++) gRS = ST.nextToken();
 552
 553         return gRS;
 554
 555     }
 556
 557     private boolean isChangeable(String name) {
 558         boolean hasChanged = false;
 559         try {
 560             Object getProp = oObj.getPropertyValue(name);
 561             System.out.println("Getting: "+getProp);
 562
 563             Object setValue = null;
 564             if (getProp != null) {
 565                 if (!utils.isVoid(getProp))
 566                     setValue = ValueChanger.changePValue(getProp);
 567                 else System.out.println("Property '"+name+
 568                     "' is void but MAYBEVOID isn't set");
 569             } else System.out.println("Property '"+name+"'is null and can't be changed");
 570             if (name.equals("LineStyle")) setValue = null;
 571             if (setValue != null) {
 572                 oObj.setPropertyValue(name, setValue);
 573                 System.out.println("Setting to :"+setValue);
 574                 hasChanged = (! getProp.equals(oObj.getPropertyValue(name)));
 575             } else System.out.println("Couldn't change Property '"+name+"'");
 576         } catch (com.sun.star.beans.PropertyVetoException e) {
 577             System.out.println("'" + name + "' throws exception '" + e + "'");
 578             e.printStackTrace();
 579         } catch (com.sun.star.lang.IllegalArgumentException e) {
 580             System.out.println("'" + name + "' throws exception '" + e + "'");
 581             e.printStackTrace();
 582         } catch (com.sun.star.beans.UnknownPropertyException e) {
 583             System.out.println("'" + name + "' throws exception '" + e + "'");
 584             e.printStackTrace();
 585         } catch (com.sun.star.lang.WrappedTargetException e) {
 586             System.out.println("'" + name + "' throws exception '" + e + "'");
 587             e.printStackTrace();
 588         } catch (com.sun.star.uno.RuntimeException e) {
 589             System.out.println("'" + name + "' throws exception '" + e + "'");
 590             e.printStackTrace();
 591         } catch (java.lang.ArrayIndexOutOfBoundsException e) {
 592             System.out.println("'" + name + "' throws exception '" + e + "'");
 593             e.printStackTrace();
 594         }
 595
 596         return hasChanged;
 597     }
 598
 599
 600 }  // finish class _XPropertySet
 601