| /************************************************************** | |
| * | |
| * 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 existence 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("Unexpected 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 possibility | |
| 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(); | |
| } |