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