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

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

1 files changed, 330 insertions, 0 deletions

diff --git a/qadevOOo/tests/java/ifc/beans/_XTolerantMultiPropertySet.java b/qadevOOo/tests/java/ifc/beans/_XTolerantMultiPropertySet.java
new file mode 100644
index 000000000..6860c8690
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/beans/_XTolerantMultiPropertySet.java
@@ -0,0 +1,330 @@
+/*
+ * 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 com.sun.star.beans.GetDirectPropertyTolerantResult;
+import com.sun.star.beans.GetPropertyTolerantResult;
+import com.sun.star.beans.Property;
+import com.sun.star.beans.PropertyAttribute;
+import com.sun.star.beans.PropertyState;
+import com.sun.star.beans.SetPropertyTolerantFailed;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.beans.XPropertyState;
+import com.sun.star.beans.XTolerantMultiPropertySet;
+import com.sun.star.uno.UnoRuntime;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import lib.MultiMethodTest;
+import lib.Status;
+import lib.StatusException;
+
+import util.ValueChanger;
+import util.ValueComparer;
+
+
+public class _XTolerantMultiPropertySet extends MultiMethodTest {
+    public XTolerantMultiPropertySet oObj;
+    protected String[] namesOfDirectProperties = null;
+    protected String[] namesOfProperties = null;
+    protected Object[] valuesOfProperties = null;
+    protected Property[] properties = null;
+    protected XPropertyState pState = null;
+    protected XPropertySet PS = null;
+
+
+    /*
+     * Queries XPropertySet from the given Component and gets XPropertySetInfo
+     * from it to get the PropertyNames available and their Values<br>
+     * Then queries XPropertyState from the given Component
+     * to get the direct properties<br>
+     * Throws a lib StatusException if the Component doesn't support XPropertySet or XPropertyState
+     */
+    @Override
+    public void before() {
+        PS = UnoRuntime.queryInterface(XPropertySet.class,
+                                                      tEnv.getTestObject());
+
+        if (PS == null) {
+            throw new StatusException(Status.failed(
+                                              "Component doesn't provide the needed XPropertySet"));
+        }
+
+        pState = UnoRuntime.queryInterface(
+                         XPropertyState.class, tEnv.getTestObject());
+
+        if (pState == null) {
+            throw new StatusException(Status.failed(
+                                              "Component doesn't provide the needed XPropertyState"));
+        }
+
+        properties = PS.getPropertySetInfo().getProperties();
+        namesOfProperties = getProperties();
+        valuesOfProperties = getPropertyValues(namesOfProperties);
+    }
+
+    /*
+     * Calls the method getDirectPropertyValuesTolerant() and compares the resulting
+     * sequence with the one gained as direct values in the before() method.<br>
+     * Has OK state if both sequences equal.
+     */
+    public void _getDirectPropertyValuesTolerant() {
+        namesOfDirectProperties = getDirectProperties(properties);
+
+        GetDirectPropertyTolerantResult[] GDPR = oObj.getDirectPropertyValuesTolerant(
+                                                         namesOfProperties);
+
+        boolean res = (GDPR.length == namesOfDirectProperties.length);
+
+        if (!res) {
+            log.println("Found: ");
+
+            for (int i = 0; i < GDPR.length; i++) {
+                log.println("\t" + GDPR[i].Name);
+            }
+
+            log.println("Expected: ");
+
+            for (int i = 0; i < namesOfDirectProperties.length; i++) {
+                log.println("\t" + namesOfDirectProperties[i]);
+            }
+        } else {
+            for (int i = 0; i < GDPR.length; i++) {
+                boolean localres = GDPR[i].Name.equals(
+                                           namesOfDirectProperties[i]);
+
+                if (!localres) {
+                    log.println("Found: ");
+                    log.println("\t" + GDPR[i].Name);
+                    log.println("Expected: ");
+                    log.println("\t" + namesOfDirectProperties[i]);
+                }
+
+                res &= localres;
+            }
+        }
+
+        tRes.tested("getDirectPropertyValuesTolerant()", res);
+    }
+
+    public void _getPropertyValuesTolerant() {
+        requiredMethod("getDirectPropertyValuesTolerant()");
+        GetPropertyTolerantResult[] GPR = oObj.getPropertyValuesTolerant(
+                                                  namesOfProperties);
+
+        boolean res = (GPR.length == namesOfProperties.length);
+
+        if (!res) {
+            log.println("Length of sequences differs");
+            log.println("Found: " + GPR.length);
+            log.println("Expected: " + namesOfProperties.length);
+        } else {
+            for (int i = 0; i < GPR.length; i++) {
+                boolean localres = true;
+
+                if (!(GPR[i].Value instanceof com.sun.star.uno.Any)) {
+                    localres = ValueComparer.equalValue(GPR[i].Value,
+                                                        valuesOfProperties[i]);
+
+                }
+
+                if (!localres) {
+                    log.println("Values differ for : " +
+                                namesOfProperties[i]);
+                    log.println("\t" + GPR[i].Value);
+                    log.println("Expected: ");
+                    log.println("\t" + valuesOfProperties[i]);
+                }
+
+                res &= localres;
+            }
+        }
+
+        tRes.tested("getPropertyValuesTolerant()", res);
+    }
+
+    public void _setPropertyValuesTolerant() {
+        requiredMethod("getPropertyValuesTolerant()");
+
+        SetPropertyTolerantFailed[] SPTF = oObj.setPropertyValuesTolerant(namesOfProperties,
+                                                  getNewValues(valuesOfProperties));
+
+        //read only properties will throw a PropertyVetoException if they are set
+        int failures = 0;
+
+        for (int k = 0; k < SPTF.length; k++) {
+            if (SPTF[k].Result == com.sun.star.beans.TolerantPropertySetResultType.PROPERTY_VETO) {
+                failures++;
+            }
+        }
+
+        int roProps = getCountOfReadOnlyProperties();
+
+        boolean res = (failures == roProps);
+
+        if (!res) {
+            log.println("Failures: " + failures);
+            log.println("Count of R/O properties: " + roProps);
+
+            for (int i = 0; i < SPTF.length; i++) {
+                if (SPTF[i].Result == com.sun.star.beans.TolerantPropertySetResultType.PROPERTY_VETO) {
+                    failures++;
+                    log.println("Failed for " + SPTF[i].Name);
+                    log.println("\t Result: " + SPTF[i].Result);
+                }
+            }
+        } else {
+            for (int i = 0; i < SPTF.length; i++) {
+                boolean localres = true;
+                GetPropertyTolerantResult[] GPR = oObj.getPropertyValuesTolerant(
+                                                          namesOfProperties);
+
+                if ((!(GPR[i].Value instanceof com.sun.star.uno.Any)) &&
+                        (SPTF[i].Result == com.sun.star.beans.TolerantPropertySetResultType.SUCCESS)) {
+                    localres = ValueComparer.equalValue(GPR[i].Value,
+                                                        valuesOfProperties[i]);
+                }
+
+                if (!localres) {
+                    log.println("Values differ for : " +
+                                namesOfProperties[i]);
+                    log.println("\t" + GPR[i].Value);
+                    log.println("Expected: ");
+                    log.println("\t" + valuesOfProperties[i]);
+                }
+
+                res &= localres;
+            }
+        }
+
+        tRes.tested("setPropertyValuesTolerant()", res);
+    }
+
+    /*
+     * This method returns a sorted list of property names
+     * contained in a given sequence of properties that additionally
+     * have the state DIRECT_VALUE
+     */
+    protected String[] getDirectProperties(Property[] props) {
+        ArrayList<String> direct = new ArrayList<String>();
+
+        for (int i = 0; i < props.length; i++) {
+            String pName = props[i].Name;
+
+            try {
+                PropertyState state = pState.getPropertyState(pName);
+
+                if (state.equals(PropertyState.DIRECT_VALUE) && isUsable(pName))
+                    direct.add(pName);
+            } catch (com.sun.star.beans.UnknownPropertyException e) {
+                log.println("Property '" + pName + "'");
+            }
+        }
+
+        Collections.sort(direct);
+
+        Object[] obj = direct.toArray();
+        String[] ret = new String[obj.length];
+
+        for (int i = 0; i < obj.length; i++) {
+            ret[i] = (String) obj[i];
+        }
+
+        return ret;
+    }
+
+    private boolean isUsable(String name) {
+        boolean isUsable=true;
+        if (name.startsWith("TextWriting")) isUsable = false;
+        if (name.startsWith("MetaFile")) isUsable = false;
+        return isUsable;
+    }
+
+    /*
+     * This method returns a sorted list of property names
+     * contained in a given sequence of properties
+     */
+    protected String[] getProperties() {
+        ArrayList<String> names = new ArrayList<String>();
+
+        for (int i = 0; i < properties.length; i++) {
+            String pName = properties[i].Name;
+            if (isUsable(pName)) names.add(pName);
+        }
+
+        Collections.sort(names);
+
+        Object[] obj = names.toArray();
+        String[] ret = new String[obj.length];
+
+        for (int i = 0; i < obj.length; i++) {
+            ret[i] = (String) obj[i];
+        }
+
+        return ret;
+    }
+
+    /*
+     * Returns the values of a given array of properties in an Object array
+     */
+    protected Object[] getPropertyValues(String[] propertyNames) {
+        Object[] values = new Object[propertyNames.length];
+
+        for (int i = 0; i < propertyNames.length; i++) {
+            try {
+                values[i] = PS.getPropertyValue(propertyNames[i]);
+            } catch (com.sun.star.beans.UnknownPropertyException e) {
+                e.printStackTrace(log);
+            } catch (com.sun.star.lang.WrappedTargetException e) {
+                e.printStackTrace(log);
+            }
+        }
+
+        return values;
+    }
+
+    protected int getCountOfReadOnlyProperties() {
+        int ro = 0;
+
+        for (int i = 0; i < properties.length; i++) {
+            Property property = properties[i];
+            boolean isWritable = ((property.Attributes & PropertyAttribute.READONLY) == 0);
+
+            if (!isWritable) {
+                ro++;
+            }
+        }
+
+        return ro;
+    }
+
+    protected Object[] getNewValues(Object[] oldValues) {
+        Object[] newValues = new Object[oldValues.length];
+
+        for (int i = 0; i < oldValues.length; i++) {
+            if (oldValues[i] instanceof com.sun.star.uno.Any) {
+                newValues[i] = oldValues[i];
+            } else {
+                newValues[i] = ValueChanger.changePValue(oldValues[i]);
+            }
+        }
+
+        return newValues;
+    }
+}