Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

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

1 files changed, 645 insertions, 0 deletions

diff --git a/qadevOOo/tests/java/ifc/beans/_XPropertySet.java b/qadevOOo/tests/java/ifc/beans/_XPropertySet.java
new file mode 100644
index 000000000..0fe6b2593
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/beans/_XPropertySet.java
@@ -0,0 +1,645 @@
+/*
+ * 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.beans;
+
+import java.util.ArrayList;
+
+import lib.MultiMethodTest;
+import util.ValueChanger;
+import util.utils;
+
+import com.sun.star.beans.Property;
+import com.sun.star.beans.PropertyAttribute;
+import com.sun.star.beans.PropertyChangeEvent;
+import com.sun.star.beans.XPropertyChangeListener;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.beans.XPropertySetInfo;
+import com.sun.star.beans.XVetoableChangeListener;
+import com.sun.star.lang.EventObject;
+
+/**
+* Testing <code>com.sun.star.beans.XPropertySet</code>
+* interface methods :
+* <ul>
+*  <li><code>getPropertySetInfo()</code></li>
+*  <li><code>setPropertyValue()</code></li>
+*  <li><code>getPropertyValue()</code></li>
+*  <li><code>addPropertyChangeListener()</code></li>
+*  <li><code>removePropertyChangeListener()</code></li>
+*  <li><code>addVetoableChangeListener()</code></li>
+*  <li><code>removeVetoableChangeListener()</code></li>
+* </ul>
+* @see com.sun.star.beans.XPropertySet
+*/
+public class _XPropertySet extends MultiMethodTest {
+
+    public XPropertySet oObj = null;
+
+    /**
+    * Flag that indicates change listener was called.
+    */
+    private boolean propertyChanged = false;
+
+    /**
+    * Listener that must be called on bound property changing.
+    */
+    public class MyChangeListener implements XPropertyChangeListener {
+         /**
+         * Just set <code>propertyChanged</code> flag to true.
+         */
+         public void propertyChange(PropertyChangeEvent e) {
+            propertyChanged = true;
+         }
+         public void disposing (EventObject obj) {}
+    }
+
+    private final XPropertyChangeListener PClistener = new MyChangeListener();
+
+    /**
+    * Flag that indicates veto listener was called.
+    */
+    private boolean vetoableChanged = false;
+
+    /**
+    * Listener that must be called on constrained property changing.
+    */
+    public class MyVetoListener implements XVetoableChangeListener {
+         /**
+         * Just set <code>vetoableChanged</code> flag to true.
+         */
+         public void vetoableChange(PropertyChangeEvent e) {
+            vetoableChanged = true;
+         }
+         public void disposing (EventObject obj) {}
+    }
+
+    private final XVetoableChangeListener VClistener = new MyVetoListener();
+
+    /**
+    * Structure that collects the properties of different types to test :
+    * Constrained, Bound and Normal.
+    */
+    private static final class PropsToTest {
+        ArrayList< String > constrained = new ArrayList< String >();
+        ArrayList< String > bound = new ArrayList< String >();
+        ArrayList< String > normal = new ArrayList< String >();
+    }
+
+    private final PropsToTest PTT = new PropsToTest();
+
+    /**
+    * Tests method <code>getPropertySetInfo</code>. After test completed
+    * call {@link #getPropsToTest} method to retrieve different kinds
+    * of properties to test then. <p>
+    * Has OK status if not null <code>XPropertySetInfo</code>
+    * object returned.<p>
+    * Since <code>getPropertySetInfo</code> is optional, it may return null,
+    * if it is not implemented. This method uses then an object relation
+    * <code>PTT</code> (Properties To Test) to determine available properties.
+    * All tests for services without <code>getPropertySetInfo</code> must
+    * provide this object relation.
+    */
+    public void _getPropertySetInfo() {
+
+        XPropertySetInfo propertySetInfo = oObj.getPropertySetInfo();
+
+        if (propertySetInfo == null) {
+            log.println("getPropertySetInfo() method returned null");
+            tRes.tested("getPropertySetInfo()", true) ;
+            String[] ptt = (String[]) tEnv.getObjRelation("PTT");
+            PTT.normal.clear();
+            PTT.bound.clear();
+            PTT.constrained.clear();
+            PTT.normal.add( ptt[0] );
+            PTT.bound.add( ptt[1] );
+            PTT.constrained.add( ptt[2] );
+        } else {
+            tRes.tested("getPropertySetInfo()", true );
+            getPropsToTest(propertySetInfo);
+        }
+    } // end of getPropertySetInfo()
+
+    /**
+    * Tests change listener which added for bound properties.
+    * Adds listener to bound property (if it exists), then changes
+    * its value and check if listener was called. <p>
+    * Method tests to be successfully completed before :
+    * <ul>
+    *  <li> <code>getPropertySetInfo</code> : in this method test
+    *    one of bound properties is retrieved. </li>
+    * </ul> <p>
+    * Has OK status if NO bound properties exist or if listener
+    * was successfully called.
+    */
+    public void _addPropertyChangeListener() {
+
+        requiredMethod("getPropertySetInfo()");
+
+        int count = PTT.bound.size();
+        if ( count==0 || PTT.bound.get(0).equals("none") ) {
+            log.println("*** No bound properties found ***");
+            tRes.tested("addPropertyChangeListener()", true) ;
+        } else {
+            boolean error = false;
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.bound.get(i);
+                propertyChanged = false;
+                try {
+                    oObj.addPropertyChangeListener(propertyName,PClistener);
+                    Object gValue = oObj.getPropertyValue(propertyName);
+                    log.println("Check bound property: " + propertyName );
+                    oObj.setPropertyValue(propertyName,
+                        ValueChanger.changePValue(gValue));
+                } catch (com.sun.star.beans.PropertyVetoException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.IllegalArgumentException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.beans.UnknownPropertyException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.WrappedTargetException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } // end of try-catch
+                error = error || !propertyChanged;
+                if (!propertyChanged) {
+                    log.println("propertyChangeListener wasn't called for '"+
+                        propertyName+"'");
+                }
+            }
+            tRes.tested("addPropertyChangeListener()", !error);
+        }
+    } // end of addPropertyChangeListener()
+
+    /**
+    * Tests vetoable listener which added for constrained properties.
+    * Adds listener to constrained property (if it exists), then changes
+    * its value and check if listener was called. <p>
+    * Method tests to be successfully completed before :
+    * <ul>
+    *  <li> <code>getPropertySetInfo</code> : in this method test
+    *    one of constrained properties is retrieved. </li>
+    * </ul> <p>
+    * Has OK status if NO constrained properties exist or if listener
+    * was successfully called.
+    */
+    public void _addVetoableChangeListener() {
+
+        requiredMethod("getPropertySetInfo()");
+
+        int count = PTT.constrained.size();
+        if ( count==0 || PTT.constrained.get(0).equals("none") ) {
+            log.println("*** No constrained properties found ***");
+            tRes.tested("addVetoableChangeListener()", true) ;
+        } else {
+            boolean error = false;
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.constrained.get(i);
+                vetoableChanged = false;
+                try {
+                    oObj.addVetoableChangeListener(propertyName,VClistener);
+                    Object gValue = oObj.getPropertyValue(propertyName);
+                    oObj.setPropertyValue(propertyName,
+                        ValueChanger.changePValue(gValue));
+                } catch (com.sun.star.beans.PropertyVetoException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.IllegalArgumentException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.beans.UnknownPropertyException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.WrappedTargetException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } // end of try-catch
+                error = error || !vetoableChanged;
+                if (!vetoableChanged) {
+                    log.println("vetoableChangeListener wasn't called for '"+
+                        propertyName+"'");
+                }
+            }
+            tRes.tested("addVetoableChangeListener()",!error);
+        }
+    } // end of addVetoableChangeListener()
+
+
+    /**
+    * Tests <code>setPropertyValue</code> method.
+    * Stores value before call, and compares it with value after
+    * call. <p>
+    * Method tests to be successfully completed before :
+    * <ul>
+    *  <li> <code>getPropertySetInfo</code> : in this method test
+    *    one of normal properties is retrieved. </li>
+    * </ul> <p>
+    * Has OK status if NO normal properties exist or if value before
+    * method call is not equal to value after.
+    */
+    public void _setPropertyValue() {
+
+        requiredMethod("getPropertySetInfo()");
+
+        Object gValue = null;
+        Object sValue = null;
+
+        int count = PTT.normal.size();
+        if ( count==0 || PTT.normal.get(0).equals("none") ) {
+            log.println("*** No changeable properties found ***");
+            tRes.tested("setPropertyValue()", true) ;
+        } else {
+            boolean error = false;
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.normal.get(i);
+                try {
+                    log.println("try to change value of property '" + propertyName + "'" );
+                    gValue = oObj.getPropertyValue(propertyName);
+                    sValue = ValueChanger.changePValue(gValue, propertyName);
+                    oObj.setPropertyValue(propertyName, sValue);
+                    sValue = oObj.getPropertyValue(propertyName);
+                } catch (com.sun.star.beans.PropertyVetoException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.IllegalArgumentException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.beans.UnknownPropertyException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.WrappedTargetException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } // end of try-catch
+                /*  this is stupid: we can't set properties whose semantics we
+                 *  don't know to random values in an arbitrary order and
+                 *  expect that to actually work.
+                if( gValue.equals(sValue) )
+                {
+                    log.println("setting property '"+ propertyName+"' failed");
+                    error = true;
+                }
+                */
+            }
+            tRes.tested("setPropertyValue()",!error);
+        } //endif
+    } // end of setPropertyValue()
+
+    /**
+    * Tests <code>getPropertyValue</code> method for the given property.
+    * Returns true if no exceptions occurred
+    */
+    private boolean getSinglePropertyValue( String propertyName )
+    {
+        boolean runOk = false;
+        try {
+            oObj.getPropertyValue(propertyName);
+            runOk = true;
+        } catch (com.sun.star.beans.UnknownPropertyException e) {
+            log.println("Exception occurred while trying to get property '"+
+                 propertyName+"'");
+            e.printStackTrace(log);
+        } catch (com.sun.star.lang.WrappedTargetException e) {
+            log.println("Exception occurred while trying to get property '"+
+                propertyName+"'");
+            e.printStackTrace(log);
+        }
+        return runOk;
+    }
+
+    /**
+    * Tests <code>getPropertyValue</code> method.
+    * Just call this method and checks for no exceptions <p>
+    * Method tests to be successfully completed before :
+    * <ul>
+    *  <li> <code>getPropertySetInfo</code> : in this method test
+    *    one of normal properties is retrieved. </li>
+    * </ul> <p>
+    * Has OK status if NO normal properties exist or if no
+    * exceptions were thrown.
+    */
+    public void _getPropertyValue() {
+
+        requiredMethod("getPropertySetInfo()");
+
+        int count = PTT.normal.size();
+        if ( count==0 || PTT.normal.get(0).equals("none") ) {
+            Property[] properties = oObj.getPropertySetInfo().getProperties();
+            if( properties.length > 0 ) {
+                String propertyName = properties[0].Name;
+                log.println("All properties are Read Only");
+                log.println("Using: "+propertyName);
+                tRes.tested("getPropertyValue()", getSinglePropertyValue( propertyName ) );
+            }
+            else {
+                log.println("*** No properties found ***");
+                tRes.tested("getPropertyValue()", true) ;
+            }
+        } else {
+            boolean error = false;
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.normal.get(i);
+                boolean runOk = getSinglePropertyValue( propertyName );
+                if( !runOk )
+                {
+                    error = true;
+                    log.println("getPropertyValue() failed for property '"+propertyName+"'");
+                }
+            }
+            tRes.tested("getPropertyValue()", !error) ;
+        }
+    }
+
+    /**
+    * Tests <code>removePropertyChangeListener</code> method.
+    * Removes change listener, then changes bound property value
+    * and checks if the listener was NOT called.
+    * Method tests to be successfully completed before :
+    * <ul>
+    *  <li> <code>addPropertyChangeListener</code> : here listener
+    *   was added. </li>
+    * </ul> <p>
+    * Has OK status if NO bound properties exist or if listener
+    * was not called and no exceptions arose.
+    */
+    public void _removePropertyChangeListener() {
+
+        requiredMethod("addPropertyChangeListener()");
+
+        int count = PTT.bound.size();
+        if ( count==0 || PTT.bound.get(0).equals("none") ) {
+            log.println("*** No bound properties found ***");
+            tRes.tested("removePropertyChangeListener()", true) ;
+        } else {
+
+            //remove all listeners first
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.bound.get(i);
+                try {
+                    oObj.removePropertyChangeListener(propertyName,PClistener);
+                } catch (Exception e) {
+                    log.println("Exception occurred while removing change listener from"+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                }
+            }
+
+            boolean error = false;
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.bound.get(i);
+                try {
+                    propertyChanged = false;
+                    oObj.addPropertyChangeListener(propertyName,PClistener);
+                    oObj.removePropertyChangeListener(propertyName,PClistener);
+                    Object gValue = oObj.getPropertyValue(propertyName);
+                    oObj.setPropertyValue(propertyName,
+                        ValueChanger.changePValue(gValue));
+                } catch (com.sun.star.beans.PropertyVetoException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.IllegalArgumentException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.beans.UnknownPropertyException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.WrappedTargetException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } // end of try-catch
+
+                error = error || propertyChanged;
+                if (propertyChanged) {
+                    log.println("propertyChangeListener was called after removing"+
+                        " for '"+propertyName+"'");
+                }
+            }
+            tRes.tested("removePropertyChangeListener()",!error);
+        }
+    } // end of removePropertyChangeListener()
+
+
+    /**
+    * Tests <code>removeVetoableChangeListener</code> method.
+    * Removes vetoable listener, then changes constrained property value
+    * and checks if the listener was NOT called.
+    * Method tests to be successfully completed before :
+    * <ul>
+    *  <li> <code>addPropertyChangeListener</code> : here vetoable listener
+    *   was added. </li>
+    * </ul> <p>
+    * Has OK status if NO constrained properties exist or if listener
+    * was NOT called and no exceptions arose.
+    */
+    public void _removeVetoableChangeListener() {
+
+        requiredMethod("addVetoableChangeListener()");
+
+        int count = PTT.constrained.size();
+        if ( count==0 || PTT.constrained.get(0).equals("none") ) {
+            log.println("*** No constrained properties found ***");
+            tRes.tested("removeVetoableChangeListener()", true) ;
+        } else {
+
+            //remove all listeners first
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.constrained.get(i);
+                try {
+                    oObj.removeVetoableChangeListener(propertyName,VClistener);
+                } catch (Exception e) {
+                    log.println("Exception occurred while removing veto listener from"+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                }
+            }
+
+            boolean error = false;
+            for (int i = 0; i < count; i++) {
+                String propertyName = PTT.constrained.get(i);
+                vetoableChanged = false;
+                try {
+                    oObj.addVetoableChangeListener(propertyName,VClistener);
+                    oObj.removeVetoableChangeListener(propertyName,VClistener);
+                    Object gValue = oObj.getPropertyValue(propertyName);
+                    oObj.setPropertyValue(propertyName,
+                        ValueChanger.changePValue(gValue));
+                } catch (com.sun.star.beans.PropertyVetoException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.IllegalArgumentException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.beans.UnknownPropertyException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } catch (com.sun.star.lang.WrappedTargetException e) {
+                    log.println("Exception occurred while trying to change "+
+                        "property '"+ propertyName+"'");
+                    e.printStackTrace(log);
+                } // end of try-catch
+                error = error || vetoableChanged;
+                if (vetoableChanged) {
+                    log.println("vetoableChangeListener was called after "+
+                        "removing for '"+propertyName+"'");
+                }
+            }
+            tRes.tested("removeVetoableChangeListener()",!error);
+        }
+    } // end of removeVetoableChangeListener()
+
+    /**
+    * Gets the properties being tested. Searches and stores by one
+    * property of each kind (Bound, Vetoable, Normal).
+    */
+    public void getPropsToTest(XPropertySetInfo xPSI) {
+
+        Property[] properties = xPSI.getProperties();
+        // some properties should not be changed in a unspecific way
+        String[] skip = {"PrinterName", "CharRelief", "IsLayerMode"};
+
+        for (int i = 0; i < properties.length; i++) {
+
+            Property property = properties[i];
+            String name = property.Name;
+
+            boolean cont = false;
+            for (int j = 0; j < skip.length; j++) {
+                if (name.equals(skip[j])){
+                    log.println("skipping '" + name + "'");
+                    cont = true;
+                }
+            }
+
+            if (cont) continue;
+
+            boolean isWritable = ((property.Attributes &
+                PropertyAttribute.READONLY) == 0);
+            boolean isNotNull = ((property.Attributes &
+                PropertyAttribute.MAYBEVOID) == 0);
+            boolean isBound = ((property.Attributes &
+                PropertyAttribute.BOUND) != 0);
+            boolean isConstr = ((property.Attributes &
+                PropertyAttribute.CONSTRAINED) != 0);
+            boolean canChange = false;
+
+            if ( !isWritable ) log.println("Property '"+name+"' is READONLY");
+
+            if (name.endsWith("URL")) isWritable = false;
+            if (name.startsWith("Fill")) isWritable = false;
+            if (name.startsWith("Font")) isWritable = false;
+            if (name.startsWith("IsNumbering")) isWritable = false;
+            if (name.startsWith("LayerName")) isWritable = false;
+            if (name.startsWith("Line")) isWritable = false;
+            if (name.startsWith("TextWriting")) isWritable = false;
+
+            if ( isWritable && isNotNull ) canChange = isChangeable(name);
+
+            if ( isWritable && isNotNull && isBound && canChange) {
+                PTT.bound.add(name);
+            }
+
+            if ( isWritable && isNotNull && isConstr && canChange) {
+                PTT.constrained.add(name);
+            }
+
+            if ( isWritable && isNotNull && canChange) {
+                PTT.normal.add(name);
+            }
+
+
+        } // endfor
+    }
+
+    public boolean isChangeable(String name) {
+        boolean hasChanged = false;
+        try {
+            Object getProp = oObj.getPropertyValue(name);
+            log.println("Getting: "+getProp);
+            if (name.equals("xinterfaceA")) {
+                System.out.println("drin");
+            }
+
+            Object setValue = null;
+            if (getProp != null) {
+                if (!utils.isVoid(getProp))
+                    setValue = ValueChanger.changePValue(getProp);
+                else log.println("Property '"+name+
+                    "' is void but MAYBEVOID isn't set");
+            } else log.println("Property '"+name+"'is null and can't be changed");
+            if (name.equals("LineStyle")) setValue = null;
+            if (setValue != null) {
+                log.println("Setting to :"+setValue);
+                oObj.setPropertyValue(name, setValue);
+                hasChanged = (! getProp.equals(oObj.getPropertyValue(name)));
+            } else log.println("Couldn't change Property '"+name+"'");
+        } catch (com.sun.star.beans.PropertyVetoException e) {
+            log.println("'" + name + "' throws exception '" + e + "'");
+            e.printStackTrace(log);
+        } catch (com.sun.star.lang.IllegalArgumentException e) {
+            log.println("'" + name + "' throws exception '" + e + "'");
+            e.printStackTrace(log);
+        } catch (com.sun.star.beans.UnknownPropertyException e) {
+            log.println("'" + name + "' throws exception '" + e + "'");
+            e.printStackTrace(log);
+        } catch (com.sun.star.lang.WrappedTargetException e) {
+            log.println("'" + name + "' throws exception '" + e + "'");
+            e.printStackTrace(log);
+        } catch (com.sun.star.uno.RuntimeException e) {
+            log.println("'" + name + "' throws exception '" + e + "'");
+            e.printStackTrace(log);
+        } catch (java.lang.ArrayIndexOutOfBoundsException e) {
+            log.println("'" + name + "' throws exception '" + e + "'");
+            e.printStackTrace(log);
+        }
+
+        return hasChanged;
+    }
+
+    /**
+    * Forces environment recreation.
+    */
+    @Override
+    protected void after() {
+        disposeEnvironment();
+    }
+
+
+}  // finish class _XPropertySet
+