xref: /trunk/main/framework/qa/complex/path_settings/PathSettingsTest.java (revision 76b6b121)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


package complex.path_settings;

import com.sun.star.beans.Property;
import com.sun.star.beans.PropertyVetoException;
import com.sun.star.beans.UnknownPropertyException;
import com.sun.star.beans.XFastPropertySet;
import com.sun.star.beans.XMultiPropertySet;
import com.sun.star.beans.XPropertySet;
import com.sun.star.beans.XPropertiesChangeListener;
import com.sun.star.beans.XPropertyChangeListener;
import com.sun.star.beans.XVetoableChangeListener;
import com.sun.star.lang.WrappedTargetException;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.AnyConverter;

// ---------- junit imports -----------------
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openoffice.test.OfficeConnection;
import static org.junit.Assert.*;
// ------------------------------------------

public class PathSettingsTest
{

    private static XMultiServiceFactory xMSF;
    // the test object: an instance of the tested service
    private static Object aPathSettings = null;
    // the properties of the service
    private static Property[] xPropertyInfoOfPathSettings = null;
    private static String[] aPathSettingNames = null;
    private static String[] availablePropNames = new String[]
    {
        "Addin",
        "AutoCorrect",
        "AutoText",
        "Backup",
        "Basic",
        "Bitmap",
        "Config",
        "Dictionary",
        "Favorite",
        "Filter",
        "Fingerprint",
        "Gallery",
        "Graphic",
        "Help",
        "Linguistic",
        "Module",
        "Palette",
        "Plugin",
        "Storage",
        "Temp",
        "Template",
        "UIConfig",
        "UserConfig",
        "Work",
    };
    // every path name from availablePropNames exist in this characteristics
    // name
    // name_internal
    // name_user
    // name_writable
    private static String[] availablePropNameExtensions = new String[]
    {
        "",
        "_internal",
        "_user",
        "_writable"
    };
    private static String[] aPathSettingValues = null;
    ArrayList<Property> aListOfWorkingProperty;

    /**
     * A function to tell the framework, which test functions are available.
     * Right now, it's only 'checkComplexTemplateState'.
     * @return All test methods.
     */
//    public String[] getTestMethodNames() {
//        return new String[]{"checkXFastPropertySet",
//                            "checkXMultiPropertySet",
//                            "checkXPropertySet"
//                        };
//    }
    /**
     * Initialize before the tests start: this has to be done only once.
     * This methods sets the 'aPathSettings' and 'xPropertyInfoOfPathSettings' variables.
     */
    @Before
    public void before()
    {
        try
        {
            xMSF = getMSF();
//            aPathSettings = xMSF.createInstance("com.sun.star.util.PathSettings");
            aPathSettings = xMSF.createInstance("com.sun.star.comp.framework.PathSettings");
            assertNotNull("Can't instantiate com.sun.star.util.PathSettings.", aPathSettings);
//            System.out.println("Implementation: " + util.utils.getImplName(aPathSettings));
//            System.out.println("Service:        ");
            util.dbg.getSuppServices(aPathSettings);
            final XPropertySet xPropSet_of_PathSettings = UnoRuntime.queryInterface(XPropertySet.class, aPathSettings);

            xPropertyInfoOfPathSettings = xPropSet_of_PathSettings.getPropertySetInfo().getProperties();
            aPathSettingNames = new String[xPropertyInfoOfPathSettings.length];
            aPathSettingValues = new String[xPropertyInfoOfPathSettings.length];

            aListOfWorkingProperty = new ArrayList<Property>();

            // get intitial values and create new ones
            for (int i = 0; i < xPropertyInfoOfPathSettings.length; i++)
            {
                final String sName = xPropertyInfoOfPathSettings[i].Name;
                // System.out.println(sName);
                aPathSettingNames[i] = sName;
                Object o = xPropSet_of_PathSettings.getPropertyValue(sName);

                String sValue = convertToString(o);
                aPathSettingValues[i] = sValue;
                aListOfWorkingProperty.add(xPropertyInfoOfPathSettings[i]);
            }
        }
        catch (com.sun.star.uno.Exception e)
        {
            System.out.println(e.getClass().getName());
            System.out.println("Message: " + e.getMessage());
            // fail("Could not create an instance of the test object.");
        }
        catch (Exception e)
        {
            fail("What exception?");
        }
    }

    private String convertToString(Object o)
    {
        String sValue = "";
        try
        {
            if (AnyConverter.isString(o))
            {
                sValue = AnyConverter.toString(o);
            }
            else if (AnyConverter.isArray(o))
            {
                Object oValueList = AnyConverter.toArray(o);
                String[] aValueList = (String[]) oValueList;
                String sValues = "";
                for (int j = 0; j < aValueList.length; j++)
                {
                    if (sValues.length() > 0)
                    {
                        sValues += ";";
                    }
                    sValues += aValueList[j];
                }
                sValue = sValues;
            }
            else
            {
                System.out.println("Can't convert Object to String");
            }
        }
        catch (com.sun.star.uno.Exception e)
        {
            /* ignore */
        }
        return sValue;
    }

    /**
     * Simple existance test, if this fails, the Lists must update
     */
    @Test
    public void checkInternalListConsistence()
    {
        // check if all Properties are in the internal test list
        for (int i = 0; i < xPropertyInfoOfPathSettings.length; i++)
        {
            final String sName = xPropertyInfoOfPathSettings[i].Name;
            boolean bOccur = checkIfNameExistsInList(sName, availablePropNames, availablePropNameExtensions);
            assertTrue("TEST IS WRONG, Name:='" + sName + "' doesn't exist in internal Test list.", bOccur);
        }

        // check if all properties in the internal list also exist in real life
        for (int i = 0; i < availablePropNames.length; i++)
        {
            final String aListName = availablePropNames[i];
            for (int j = 0; j < availablePropNameExtensions.length; j++)
            {
                final String aSubListName = availablePropNameExtensions[j];
                final String aName = aListName + aSubListName;
                boolean bOccur = checkIfNameExistsInList(aName, aPathSettingNames, new String[]
                        {
                            ""
                        } /* list must not empty! */);
                assertTrue("TEST IS WRONG, Name:='" + aName + "' from the internal test list do not occur in real life path settings.", bOccur);
            }
        }
    }

    /**
     * Simple O(n^n) check if a given String (_sNameMustOccur) exist in the given list(+SubList) values.
     * @param _sNameMustOccur
     * @param _aList
     * @param _aSubList
     * @return true, if name occur
     */
    private boolean checkIfNameExistsInList(String _sNameMustOccur, String[] _aList, String[] _aSubList)
    {
        for (int i = 0; i < _aList.length; i++)
        {
            final String aListName = _aList[i];
            for (int j = 0; j < _aSubList.length; j++)
            {
                final String aSubListName = _aSubList[j];
                final String aName = aListName + aSubListName;
                if (aName.equals(_sNameMustOccur))
                {
                    return true;
                }
            }
        }
        return false;
    }

    private String getPropertyValueAsString(String _sName)
    {
        final XPropertySet xPropSet_of_PathSettings = UnoRuntime.queryInterface(XPropertySet.class, aPathSettings);
        String sValue = "";
        {
            Object o;
            try
            {
                o = xPropSet_of_PathSettings.getPropertyValue(_sName);
                sValue = convertToString(o);
            }
            catch (UnknownPropertyException ex)
            {
            }
            catch (WrappedTargetException ex)
            {
            }
        }
        return sValue;
    }

    /**
     * Shows the path settings
     * @throws UnknownPropertyException
     * @throws WrappedTargetException
     */
    @Test
    public void showPathSettings() throws UnknownPropertyException, WrappedTargetException
    {
        System.out.println("\n---- All properties ----");
        final XPropertySet xPropSet_of_PathSettings = UnoRuntime.queryInterface(XPropertySet.class, aPathSettings);

//        for (int i = 0; i < xPropertyInfoOfPathSettings.length; i++)
        for (int i = 0; i < aListOfWorkingProperty.size(); i++)
        {
            final String sName = aListOfWorkingProperty.get(i).Name;
            // aPathSettingWorkingNames[i] = sName;
//            System.out.print("PathSettings: Name:=");
            System.out.print(sName);
            Object o = xPropSet_of_PathSettings.getPropertyValue(sName);

            // System.out.println("#### Object: '" + o.getClass().getName() + "'  -  '" + o.toString() + "'");
            try
            {
                final String sValue = AnyConverter.toString(o);
                // aPathSettingValues[i] = sValue;
                // System.out.println("#### String " + sValue);
                // System.out.println("Property Name: " + sName);
                // System.out.println("Property Value: " + sValue);
//                System.out.print(" ==> ");
//                System.out.print(sValue);
            }
            catch (com.sun.star.uno.Exception e)
            {
//                System.out.print(" FAILED ");
            }
            System.out.println();
        }
        System.out.println("---- Finish showing properties ----\n");
    }

    private boolean checkPaths(Object _o, Object _o2)
    {
        String sLeftPath = "";
        String sRightPath = "";
        if (AnyConverter.isArray(_o))
        {
            try
            {
                Object oValues = AnyConverter.toArray(_o);
                sLeftPath = convertToString(oValues);
            }
            catch (com.sun.star.lang.IllegalArgumentException e)
            {
            }
        }
        else if (AnyConverter.isString(_o))
        {
            try
            {
                sLeftPath = AnyConverter.toString(_o);
            }
            catch (com.sun.star.lang.IllegalArgumentException e)
            {
            }
        }

        if (AnyConverter.isArray(_o2))
        {
            try
            {
                Object oValues = AnyConverter.toArray(_o2);
                sRightPath = convertToString(oValues);
            }
            catch (com.sun.star.lang.IllegalArgumentException e)
            {
            }
        }
        else if (AnyConverter.isString(_o2))
        {
            try
            {
                sRightPath = AnyConverter.toString(_o2);
            }
            catch (com.sun.star.lang.IllegalArgumentException e)
            {
            }
        }
        return checkPaths(sLeftPath, sRightPath);
    }

    /**
     * Check 2 given paths if the _aOtherPath exists in _aPath, _aPath could be a list separated by ';'
     * @param _aPath
     * @param _aOtherPath
     * @return true, if _aOtherPath found
     */
    private boolean checkPaths(String _aPath, String _aOtherPath)
    {
        if (_aOtherPath.contains(";"))
        {
            StringTokenizer aToken = new StringTokenizer(_aOtherPath, ";");
            int nCount = 0;
            int nFound = 0;
            while (aToken.hasMoreElements())
            {
                String sPath = (String)aToken.nextElement();
                nCount ++;
                if (checkPaths(_aPath, sPath))
                {
                    nFound++;
                }
            }
            if (nFound == nCount)
            {
                return true;
            }
        }
        else if(_aPath.contains(";"))
        {
            StringTokenizer aToken = new StringTokenizer(_aPath, ";");
            while (aToken.hasMoreElements())
            {
                String sToken = (String)aToken.nextElement();
                if (sToken.equals(_aOtherPath))
                {
                    return true;
                }
            }
            return false;
        }
        else if (_aPath.equals(_aOtherPath))
        {
            return true;
        }
        return false;
    }

    /**
     * This tests the XFastPropertySet interface implementation.
     */
    @Test
    public void checkXFastPropertySet()
    {
        System.out.println("---- Testing the XFastPropertySet interface ----");


        // do for all properties
        // xPropertyInfoOfPathSettings.length
        for (int i = 0; i < aListOfWorkingProperty.size(); i++)
        {
            final Property property = aListOfWorkingProperty.get(i); // xPropertyInfoOfPathSettings[i];
            String name = property.Name;
            // get property name and initial value
            System.out.println("Test property with name: " + name);
            boolean bResult;
            if (name.endsWith("_writable"))
            {
                bResult = checkStringProperty(property);
            }
            else if (name.endsWith("_user"))
            {
                bResult = checkStringListProperty(property);
            }
            else if (name.endsWith("_internal"))
            {
                bResult = checkStringListProperty(property);
            }
            else
            {
                // old path settings
                bResult = checkStringProperty(property);
            }
            System.out.print(" Test of property " + name + " finished");
            if (bResult)
            {
                System.out.println(" [ok]");
            }
            else
            {
                System.out.println(" [FAILED]");
            }
            System.out.println();
        }
        System.out.println("---- Test of XFastPropertySet finished ----\n");
    }

    private boolean checkStringListProperty(Property property)
    {
        // creating instances
        boolean bResult = true;
        XFastPropertySet xFPS = UnoRuntime.queryInterface(XFastPropertySet.class, aPathSettings);

        String name = property.Name;
        int handle = property.Handle;

        Object oValue;
        try
        {
            oValue = xFPS.getFastPropertyValue(handle);
        }
        catch (UnknownPropertyException ex)
        {
            return false;
        }
        catch (WrappedTargetException ex)
        {
            return false;
        }

        if (!AnyConverter.isArray(oValue))
        {
            System.out.println(" Internal error, type wrong. PathSetting property with name:" + name + " should be an array.");
            return false;
        }

        String val;
        try
        {
            Object oValues = AnyConverter.toArray(oValue);


            final String[] aValues = (String[])oValues;

            // aNewValues contains a deep copy of aValues
            String[] aNewValues = new String[aValues.length];
            System.arraycopy(aValues, 0, aNewValues, 0, aValues.length);
            if (aValues.length > 0)
            {
                val = aValues[0];
            }
            else
            {
                val = null;
                aNewValues = new String[1]; // create a String list
            }
            System.out.println(" Property has initial value: '" + val + "'");

            // set to a new correct value
            String newVal = changeToCorrectValue(val);
            assertFalse("newVal must not equal val.", newVal.equals(val));

            System.out.println(" Try to change to a correct value '" + newVal + "'");
            aNewValues[0] = newVal;

            try
            {
                try
                {
                    xFPS.setFastPropertyValue(handle, aNewValues);
                }
                catch (com.sun.star.lang.WrappedTargetException e)
                {
                    System.out.println(" FAIL: setFastPropertyValue(handle:=" + handle + ", name:='" + name + "')" + e.getMessage());
                    bResult = false;
                }

                // Property_internal can't change we will not arrive bejond this line

                // check the change
                Object oObj = xFPS.getFastPropertyValue(handle);
                if (!checkPaths(oObj, aNewValues))
                {
                    System.out.println(" FAIL: Did not change value on property " + name + ".");
                    bResult = false;
                }

                // set back to initial setting
                System.out.println(" Try to check");
                try
                {
                    xFPS.setFastPropertyValue(handle, oValue);
                }
                catch (com.sun.star.beans.PropertyVetoException e)
                {
                    // should not occur
                    System.out.println(" FAIL: PropertyVetoException caught: " + e.getMessage());
                    bResult = false;
                }
            }
            catch (com.sun.star.beans.PropertyVetoException e)
            {
                if (!name.endsWith("_internal"))
                {
                    // should not occur
                   System.out.println(" FAIL: PropertyVetoException caught: " + e.getMessage());
                   bResult = false;
                }
                else
                {
                   System.out.println(" OK: PropertyVetoException caught: " + e.getMessage() + " it seems not allowed to change internal values.");
                }
            }

            // check if changed
            Object checkVal3 = xFPS.getFastPropertyValue(handle);
            if (!checkPaths(checkVal3, oValues))
            {
                System.out.println(" FAIL: Can't change value back to original on property " + name);
                bResult = false;
            }
        }
        catch (com.sun.star.uno.Exception e)
        {
            System.out.println(" FAIL: getFastPropertyValue(handle:=" + handle + ", name:='" + name + "')" + e.getMessage());
            bResult = false;
        }
        return bResult;
    }

    private boolean checkStringProperty(Property property)
    {
        boolean bResult = true;
        XFastPropertySet xFPS = UnoRuntime.queryInterface(XFastPropertySet.class, aPathSettings);
        String name = property.Name;
        int handle = property.Handle;
        Object oValue;
        try
        {
            oValue = xFPS.getFastPropertyValue(handle);
        }
        catch (UnknownPropertyException ex)
        {
            return false;
        }
        catch (WrappedTargetException ex)
        {
            return false;
        }


        try
        {
            String val = "";
            val = AnyConverter.toString(oValue);
            System.out.println(" Property has initial value: '" + val + "'");

            // set to a new correct value
            String newVal = changeToCorrectValue(val);
            System.out.println(" Try to change to a correct value '" + newVal + "'");
            xFPS.setFastPropertyValue(handle, newVal);

            // check the change
            String checkVal = (String) xFPS.getFastPropertyValue(handle);
            if (!checkPaths(checkVal, newVal))
            {
                System.out.println("  FAIL: Did not change value on property " + name + ".");
                bResult = false;
            }
            newVal = changeToIncorrectValue(val);
            System.out.println(" Try to change to incorrect value '" + newVal + "'");
            try
            {
                xFPS.setFastPropertyValue(handle, newVal);
            }
            catch (com.sun.star.lang.IllegalArgumentException e)
            {
                System.out.println("  Correctly thrown Exception caught.");
            }

            // check if changed
            String checkVal2 = (String) xFPS.getFastPropertyValue(handle);
            if (!checkPaths(checkVal2, checkVal))
            {
                System.out.println("  FAIL: Value did change on property " + name + " though it should not have.");
                bResult = false;
            }
            else
            {
                System.out.println("  OK: Incorrect value was not set.");
            }
            // set back to initial setting
            System.out.println(" Set back to initial value.");
            try
            {
                xFPS.setFastPropertyValue(handle, val);
            }
            catch (com.sun.star.lang.IllegalArgumentException e)
            {
                System.out.println("  IllegalArgumentException caught: " + e.getMessage());
                bResult = false;
            }
            // check if changed
            String checkVal3 = (String) xFPS.getFastPropertyValue(handle);
            if (!checkVal3.equals(val))
            {
                if (!checkPaths(checkVal3, val))
                {
                    System.out.println("  FAIL: Can't change value back to original on property " + name);
                    System.out.println("  Value is: " + checkVal3);

                    bResult = false;
                }
                else
                {
                    System.out.println("  OK: the pathsettings contains the original path.");
                    System.out.println("         Value is: " + checkVal3);
                    System.out.println("  Value should be: " + val);
                }
            }
            else
            {
                System.out.println("  OK: Change value back to original on property " + name);
            }
        }
        catch (com.sun.star.uno.Exception e)
        {
            System.out.println(" FAIL: getFastPropertyValue(handle:=" + handle + ", name:='" + name + "')" + e.getMessage());
            bResult = false;
        }
        return bResult;
    }

    // ____________________
    /**
     * This tests the XMultiPropertySet interface implementation.
     */

    // The test checkXMultiPropertySet() has been marked as outdated!

//    @Test
//    public void checkXMultiPropertySet()
//    {
//        System.out.println("---- Testing the XMultiPropertySet interface ----");
//        XMultiPropertySet xMPS = UnoRuntime.queryInterface(XMultiPropertySet.class, aPathSettings);
//
//        // xPropertyInfoOfPathSettings.length
//        String[] propertiesToTest = new String[1];
//        propertiesToTest[0] = availablePropNames[0];
//
//        String[] correctVals = new String[propertiesToTest.length];
//        String[] incorrectVals = new String[propertiesToTest.length];
//
//        String[] aPathSettingWorkingNames = null;
//        aPathSettingWorkingNames = new String[propertiesToTest.length];
//
//        // get intitial values and create new ones
//        for (int i = 0; i < propertiesToTest.length; i++)
//        {
//            // Property aProp = aListOfWorkingProperty.get(i);
//            final String sName = propertiesToTest[i];
//            final String sValue = getPropertyValueAsString(sName);
//            aPathSettingWorkingNames[i] = sName;
//            correctVals[i] = changeToCorrectValue(sValue);
//            incorrectVals[i] = changeToIncorrectValue(sValue);
//        }
//
//        try
//        {
//            // add a change listener
//            MyChangeListener mListener = new MyChangeListener();
//            xMPS.addPropertiesChangeListener(aPathSettingWorkingNames, mListener);
//
//            // first change xPropertyInfoOfPathSettings to correct values
//            System.out.println("Change to correct values.");
//            xMPS.setPropertyValues(aPathSettingWorkingNames, correctVals);
//            assertTrue("Could not change to correct values with XMultiPropertySet.",
//                    verifyPropertySet(xMPS, aPathSettingWorkingNames, correctVals) > 0);
//
//            // second, change to incorrect values: expect an exception
//            System.out.println("Try to change to incorrect values.");
//            try
//            {
//                xMPS.setPropertyValues(aPathSettingWorkingNames, incorrectVals);
//            }
//            catch (com.sun.star.lang.IllegalArgumentException r)
//            {
//                System.out.println("Correctly thrown Exception caught.");
//            }
//            assertTrue("Did change to incorrect values with XMultiPropertySet,"
//                    + " but should not have.",
//                    verifyPropertySet(xMPS, aPathSettingWorkingNames, correctVals) > 0);
//
//            // third, change back to initial values
//            System.out.println("Change back to initial values.");
//            xMPS.setPropertyValues(aPathSettingWorkingNames, aPathSettingValues);
//            assertTrue("Could not change back to initial values with"
//                    + " XMultiPropertySet.",
//                    verifyPropertySet(xMPS, aPathSettingWorkingNames, aPathSettingValues) > 0);
//
//            // fire the event for the listener
//            System.out.println("Fire event.");
//            xMPS.firePropertiesChangeEvent(aPathSettingWorkingNames, mListener);
//            assertTrue("Event was not fired on XMultiPropertySet.",
//                    mListener.changePropertiesEventFired());
//        }
//        catch (com.sun.star.uno.Exception e)
//        {
////            e.printStackTrace();
//            System.out.println(e.getClass().getName());
//            System.out.println("Message: " + e.getMessage());
//            fail("Unexpected exception on XMultiPropertySet.");
//        }
//
//        // test finished
//        System.out.println("---- Test of XMultiPropertySet finished ----\n");
//    }

    /**
     * Verify if the values of xPropSet_of_PathSettings are the same as vals.
     * @param xPropSet_of_PathSettings A XMultiPropertySet.
     * @param aPathSettingWorkingNames An array with property names.
     * @param vals An array with values of the properties
     * @return -1 if none are equal, 1 if all are equal, 0 if some were equal
     * and some not.
     * @throws com.sun.star.lang.IllegalArgumentException
     */
//    private int verifyPropertySet(XMultiPropertySet xProp,
//            String[] propNames, String[] vals)
//    {
//        int ret = 0;
//        if (vals.length != propNames.length)
//        {
//            System.out.println("Length of array parameters must be equal.");
//            return ret;
//        }
//        for (int i = 0; i < vals.length; i++)
//        {
//            Object[] objs = xProp.getPropertyValues(new String[]
//                    {
//                        propNames[i]
//                    });
//            String retVal = (String) objs[0];
//            boolean nCheck = retVal.equals(vals[i]);
//            if (!nCheck)
//            {
//                System.out.println("Property '" + propNames[i]
//                        + "' was supposed to have value:");
//                System.out.println(vals[i]);
//                System.out.println("but has value:");
//                System.out.println(retVal);
//            }
//            // initialize
//            if (i == 0)
//            {
//                ret = nCheck ? 1 : -1;
//                continue;
//            }
//            // return 0 if equal state changes compared to initial value
//            if ((nCheck && ret < 0) || (!nCheck && ret > 0))
//            {
//                ret = 0;
//            }
//        }
//        return ret;
//    }

    // ____________________
    /**
     * This tests the XPropertySet interface implementation.
     */

// The test checkXPropertySet() has been marked as outdated!


//    @Test
//    public void checkXPropertySet()
//    {
//        System.out.println("---- Testing the XPropertySet interface ----");
//
//        XPropertySet xPS = UnoRuntime.queryInterface(XPropertySet.class, aPathSettings);
//
//        MyChangeListener mListener1 = new MyChangeListener();
//        MyChangeListener mListener2 = new MyChangeListener();
//
//        for (int i = 0; i < xPropertyInfoOfPathSettings.length; i++)
//        {
//            // adding listeners
//            String name = aPathSettingNames[i];
//            System.out.println("Testing property '" + name + "'");
//            try
//            {
//                System.out.println("Add 2 Listeners.");
//                xPS.addPropertyChangeListener(name, mListener1);
//                xPS.addVetoableChangeListener(name, mListener1);
//                xPS.addPropertyChangeListener(name, mListener2);
//                xPS.addVetoableChangeListener(name, mListener2);
//
//                // change the property
//                System.out.println("Change value.");
//                String changeVal = changeToCorrectValue(aPathSettingValues[i]);
//                xPS.setPropertyValue(name, changeVal);
//                String newVal = (String) xPS.getPropertyValue(name);
//
//                assertTrue("Value did not change on property " + name + ".",
//                        newVal.equals(changeVal));
//
//                assertTrue("Listener 1 was not called.", checkListener(mListener1));
//                assertTrue("Listener 2 was not called.", checkListener(mListener2));
//
//                mListener1.resetListener();
//                mListener2.resetListener();
//
//                System.out.println("Remove Listener 1.");
//
//                xPS.removePropertyChangeListener(name, mListener1);
//                xPS.removeVetoableChangeListener(name, mListener1);
//
//                // change the property
//                System.out.println("Change value back.");
//                xPS.setPropertyValue(name, aPathSettingValues[i]);
//                newVal = (String) xPS.getPropertyValue(name);
//                assertTrue("Value did not change on property " + name,
//                        newVal.equals(aPathSettingValues[i]));
//
//                assertTrue("Listener was called, although it was removed on"
//                        + " property " + name + ".", !checkListener(mListener1));
//                assertTrue("Listener 2 was not called on property " + name + ".",
//                        checkListener(mListener2));
//            }
//            catch (com.sun.star.uno.Exception e)
//            {
//                System.out.println(e.getClass().getName());
//                System.out.println("Message: " + e.getMessage());
//                fail("Unexpcted exception on property " + name);
//            }
//            System.out.println("Finish testing property '" + aPathSettingNames[i] + "'\n");
//        }
//        System.out.println("---- Test of XPropertySet finished ----\n");
//
//    }

//    private boolean checkListener(MyChangeListener ml)
//    {
//        return ml.changePropertyEventFired()
//                || ml.changePropertiesEventFired()
//                || ml.vetoableChangeEventFired();
//    }

    // ____________________
    /**
     * Change the given String to a correct path URL.
     * @return The changed path URL.
     */
    private String changeToCorrectValue(String path)
    {
        // the simplest possiblity
        if (path == null || path.equals(""))
        {
            String sTempDir = System.getProperty("java.io.tmpdir");
            sTempDir = util.utils.getFullURL(sTempDir);
            return sTempDir; // "file:///tmp";
        }
        return graphical.FileHelper.appendPath(path, "tmp");
    }

    /**
     * Change the given String to an incorrect path URL.
     * @return The changed path URL.
     */
    private String changeToIncorrectValue(String path)
    {
        // return an illegal path
        return "fileblablabla";
    }

    /**
     * Listener implementation which sets a flag when
     * listener was called.
     */
    public class MyChangeListener implements XPropertiesChangeListener,
            XPropertyChangeListener,
            XVetoableChangeListener
    {

        private boolean propChanged = false;
        private boolean propertiesChanged = false;
        private boolean disposeCalled = false;
        private boolean vetoableChanged = false;

        public void propertiesChange(
                com.sun.star.beans.PropertyChangeEvent[] e)
        {
            propertiesChanged = true;
        }

        public void vetoableChange(com.sun.star.beans.PropertyChangeEvent pE)
                throws com.sun.star.beans.PropertyVetoException
        {
            vetoableChanged = true;
        }

        public void propertyChange(com.sun.star.beans.PropertyChangeEvent pE)
        {
            propChanged = true;
        }

        public void disposing(com.sun.star.lang.EventObject eventObject)
        {
            disposeCalled = true;
        }

        public void resetListener()
        {
            propChanged = false;
            propertiesChanged = false;
            disposeCalled = false;
            vetoableChanged = false;
        }

        public boolean changePropertyEventFired()
        {
            return propChanged;
        }

        public boolean changePropertiesEventFired()
        {
            return propertiesChanged;
        }

        public boolean vetoableChangeEventFired()
        {
            return vetoableChanged;
        }
    }

    private XMultiServiceFactory getMSF()
    {
        final XMultiServiceFactory xMSF1 = UnoRuntime.queryInterface(XMultiServiceFactory.class, connection.getComponentContext().getServiceManager());
        return xMSF1;
    }

    // setup and close connections
    @BeforeClass
    public static void setUpConnection() throws Exception
    {
        System.out.println("setUpConnection()");
        connection.setUp();
    }

    @AfterClass
    public static void tearDownConnection()
            throws InterruptedException, com.sun.star.uno.Exception
    {
        System.out.println("tearDownConnection()");
        connection.tearDown();
    }
    private static final OfficeConnection connection = new OfficeConnection();
}