| /************************************************************** |
| * |
| * 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.filter.misc; |
| |
| import com.sun.star.beans.PropertyValue; |
| import com.sun.star.container.NoSuchElementException; |
| import com.sun.star.container.XNameAccess; |
| import com.sun.star.container.XNameContainer; |
| import com.sun.star.container.XNameReplace; |
| import com.sun.star.lang.IllegalArgumentException; |
| import com.sun.star.lang.WrappedTargetException; |
| import com.sun.star.lang.WrappedTargetRuntimeException; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.uno.UnoRuntime; |
| import com.sun.star.uno.XInterface; |
| import com.sun.star.util.XFlushable; |
| // import complexlib.ComplexTestCase; |
| // import util.utils; |
| |
| // ---------- junit imports ----------------- |
| 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.*; |
| // ------------------------------------------ |
| |
| /** |
| * This complex test checks the functionality of the properties "Finalized" and "Mandatory" of |
| * the services <CODE>com.sun.star.document.FilterFactory</CODE> and |
| * <CODE>com.sun.star.document.TypeDetection</CODE>. |
| * |
| * Each of theses services represent a container of <CODE>PropertyValue[]</CODE>. |
| * The <CODE>PropertyValue[]</CODE> contains among others the properties called |
| * <CODE>Finalized</CODE> and <CODE>Mandatory</CODE>. If the property |
| * <CODE>Finalized</CODE> is set to <CODE>true</CODE>, a filter can be removed |
| * but will not be able to be changed. |
| * If the property <CODE>Mandatory</CODE> is set to <CODE>true</CODE>, the filter |
| * can not be removed. |
| * |
| * Every filter, which is registered to the office, will be tested. For every filter-test |
| * a new instance of the mentioned services will be created. |
| |
| * During the test the property <CODE>UIName</CODE> |
| * will be changed and the service will be flushed. The test checks for expected exceptions: |
| * If the property <CODE>Finalized</CODE> equals |
| * <CODE>true</CODE> the tests check if an <CODE>Exception</CODE> must be thrown. |
| * The next step of the test is the removal of the filter was removed, than the service |
| * will be flushed. The test checks for expected exceptions: If the property |
| * <CODE>Madantory</CODE> equals <CODE>true</CODE>, an <CODE>Exception</CODE> must |
| * be thrown. |
| * This test results <CODE>false</CODE> state if there is no filter available with: |
| * <CODE>Finalized=true</CODE> |
| * <CODE>Finalized=false</CODE> |
| * <CODE>Mandatory=true</CODE> |
| * <CODE>Mandatory=false</CODE> |
| */ |
| public class FinalizedMandatoryTest |
| { |
| |
| static XMultiServiceFactory xMSF; |
| |
| /** |
| * A function to tell the framework, which test functions are available. |
| * @return All test methods. |
| */ |
| // public String[] getTestMethodNames() { |
| // return new String[]{"checkReadonlySupportFilterFactory", |
| // "checkReadonlySupportTypeDetection"}; |
| // } |
| /** Create the environment for following tests. |
| * Use either a component loader from desktop or |
| * from frame |
| * @throws Exception Exception |
| */ |
| @Before public void before() throws Exception |
| { |
| |
| // create TypeDetection |
| xMSF = getMSF(); |
| assertNotNull("Could not get XMultiServiceFactory", xMSF); |
| |
| } |
| |
| /** |
| * Creates an instance for the given <CODE>serviceName</CODE> |
| * @param serviceName the name of the service which should be created |
| * @throws Exception was thrown if creataion failes |
| * @return <CODE>XInterface</CODE> of service |
| */ |
| private XInterface getTestObject(String serviceName) throws Exception |
| { |
| |
| Object oInterface = xMSF.createInstance(serviceName); |
| |
| assertNotNull("Service wan't created", oInterface); |
| // if (oInterface == null) { |
| // failed("Service wasn't created") ; |
| // throw new Exception("could not create service '"+serviceName+"'"); |
| // } |
| return (XInterface) oInterface; |
| } |
| |
| /** |
| * call the function <CODE>checkReadonlySupport</CODE> to test <CODE>com.sun.star.document.FilterFactory</CODE> |
| * @see com.sun.star.document.FilterFactory |
| */ |
| @Test public void checkReadonlySupportFilterFactory() |
| { |
| checkReadonlySupport("com.sun.star.document.FilterFactory"); |
| } |
| |
| /** |
| * call the function <CODE>checkReadonlySupport</CODE> to test <CODE>com.sun.star.document.TypeDetection</CODE> |
| * @see com.sun.star.document.TypeDetection |
| */ |
| @Test public void checkReadonlySupportTypeDetection() |
| { |
| checkReadonlySupport("com.sun.star.document.TypeDetection"); |
| } |
| |
| /** |
| * test the given service <CODE>serviceName</CODE>. |
| * For every filter a new instace was created and the tests started. |
| * @param serviceName the name of the service to test |
| */ |
| private void checkReadonlySupport(String serviceName) |
| { |
| System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); |
| System.out.println("testing service '" + serviceName + "'"); |
| |
| XInterface oObj = null; |
| try |
| { |
| oObj = getTestObject(serviceName); |
| System.out.println("ImplName: " + util.utils.getImplName(oObj)); |
| } |
| catch (java.lang.Exception e) |
| { |
| fail("could not get test object"); |
| } |
| |
| boolean mandantoryTrue = false; |
| boolean mandantoryFalse = false; |
| boolean finalizedTrue = false; |
| boolean finalizedFalse = false; |
| |
| |
| XNameAccess xNA = UnoRuntime.queryInterface(XNameAccess.class, oObj); |
| String[] filterNames = xNA.getElementNames(); |
| |
| // XNameContainer; XNameReplace |
| String filterName = filterNames[0]; |
| Object[] instance = null; |
| |
| for (int i = 0; i < filterNames.length; i++) |
| { |
| System.out.println("------------------------------------------------"); |
| try |
| { |
| PropertyValue instanceProp = new PropertyValue(); |
| filterName = filterNames[i]; |
| System.out.println(filterName); |
| |
| // testobject must new created for every test. |
| // We change in a loop the container and try to flush this changes. |
| // If we get an expected exception this container is corrupt. It's |
| // similar to a document which could not be saved beacuse of invalid |
| // contend. While you don't remove the invalid conted you will never |
| // be able to save the document. Same here. |
| try |
| { |
| oObj = getTestObject(serviceName); |
| } |
| catch (java.lang.Exception e) |
| { |
| fail("could not get test object"); |
| } |
| |
| xNA = UnoRuntime.queryInterface(XNameAccess.class, oObj); |
| XNameContainer xNC = UnoRuntime.queryInterface(XNameContainer.class, oObj); |
| XNameReplace xNR = UnoRuntime.queryInterface(XNameReplace.class, oObj); |
| XFlushable xFlush = UnoRuntime.queryInterface(XFlushable.class, oObj); |
| |
| instance = (Object[]) xNA.getByName(filterName); |
| PropertyValue[] props = (PropertyValue[]) instance; |
| |
| printPropertyValues(props); |
| |
| boolean isMandatory = ((Boolean) getPropertyValueValue(props, "Mandatory")).booleanValue(); |
| boolean isFinalized = ((Boolean) getPropertyValueValue(props, "Finalized")).booleanValue(); |
| |
| // memory if every state is available |
| mandantoryTrue |= isMandatory; |
| mandantoryFalse |= !isMandatory; |
| |
| finalizedTrue |= isFinalized; |
| finalizedFalse |= !isFinalized; |
| |
| //change the filter |
| setPropertyValueValue((PropertyValue[]) instance, "UIName", "dummy"); |
| |
| // 1a.) try to change the filter in the container |
| try |
| { |
| xNR.replaceByName(filterName, instance); |
| } |
| catch (IllegalArgumentException e) |
| { |
| fail("could not replace filter properties ('" + filterName + "')"); |
| } |
| |
| // 1b.) try to wirte the changed filter to the configuration. |
| // This must result in a exception if the filter is finalized. |
| boolean flushError = false; |
| try |
| { |
| xFlush.flush(); |
| } |
| catch (WrappedTargetRuntimeException e) |
| { |
| flushError = true; |
| assertTrue("Unexpected exception wihle flushing changed filter '" + filterName + "'", isFinalized); |
| } |
| assertTrue("Expected exception was not thorwn while flushing changed filter '" + filterName + "' Finalized:" + isFinalized, |
| !(flushError ^ isFinalized)); |
| |
| |
| |
| // 2a.) try to remove the filter from the container |
| try |
| { |
| xNC.removeByName(filterName); |
| } |
| catch (NoSuchElementException e) |
| { |
| fail("could not remove filter from container ('" + filterName + "')"); |
| } |
| // 1b.) try to wirte the changed filter to the configuration. |
| // This must result in a exception if the filter is mandatory |
| flushError = false; |
| try |
| { |
| xFlush.flush(); |
| } |
| catch (WrappedTargetRuntimeException e) |
| { |
| flushError = true; |
| assertTrue("Unexpected exception wihle flushing removed filter '" + filterName + "'", isMandatory); |
| } |
| assertTrue("Expected exception was not thorwn while flushing removed filter '" + filterName + "' Mandatory:" + isMandatory, |
| !(flushError ^ isMandatory)); |
| |
| } |
| catch (NoSuchElementException e) |
| { |
| fail("Couldn't get elements from object"); |
| } |
| catch (WrappedTargetException e) |
| { |
| fail("Couldn't get elements from object"); |
| } |
| } |
| String preMsg = "Could not find filter with state "; |
| String postMsg = " Please check if such filter is installed!"; |
| assertTrue(preMsg + "'Mandatory=true'" + postMsg, mandantoryTrue); |
| assertTrue(preMsg + "'Mandatory=false'" + postMsg, mandantoryFalse); |
| assertTrue(preMsg + "'Finalized=true'" + postMsg, finalizedTrue); |
| assertTrue(preMsg + "'Finalized=false'" + postMsg, finalizedFalse); |
| } |
| |
| /** |
| * print all propeties with its values to <CODE>logger</CODE>. For debug purposes. |
| * @see stats.SimpleLogWriter |
| * @see com.sun.star.beans.PropertyValue |
| * @param props Sequenze of PropertyValue |
| */ |
| protected void printPropertyValues(PropertyValue[] props) |
| { |
| int i = 0; |
| while (i < props.length) |
| { |
| System.out.println(props[i].Name + ":" + props[i].Value.toString()); |
| i++; |
| } |
| if (i < props.length) |
| { |
| System.out.println(props[i].Name + ":" + props[i].Value.toString()); |
| } |
| } |
| |
| /** |
| * returns the value of the specified (<CODE>pName</CODE>) property from a sequenze of <CODE>PropertyValue</CODE> |
| * @param props a sequenze of <CODE>PropertyVlaue</CODE> |
| * @param pName the name of the property the value shoud be returned |
| * @return the value of the property |
| */ |
| protected Object getPropertyValueValue(PropertyValue[] props, String pName) |
| { |
| int i = 0; |
| while (i < props.length && !props[i].Name.equals(pName)) |
| { |
| i++; |
| } |
| return i < props.length ? props[i].Value : null; |
| } |
| |
| /** |
| * set a value of the specified (<CODE>pName</CODE>) property inside a sequenze of <CODE>PropertyValue</CODE> |
| * @param props sequenze of <CODE>PropertyValue</CODE> |
| * @param pName name of the property which should be changed |
| * @param pValue the value the property should be assigned |
| */ |
| protected void setPropertyValueValue(PropertyValue[] props, String pName, Object pValue) |
| { |
| int i = 0; |
| while (i < props.length && !props[i].Name.equals(pName)) |
| { |
| i++; |
| } |
| props[i].Value = pValue; |
| } |
| |
| 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(); |
| } |