| /************************************************************** | |
| * | |
| * 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.loadAllDocuments; | |
| import com.sun.star.beans.PropertyValue; | |
| import com.sun.star.frame.FrameSearchFlag; | |
| import com.sun.star.frame.XComponentLoader; | |
| import com.sun.star.frame.XFrame; | |
| import com.sun.star.frame.XStorable; | |
| import com.sun.star.io.XInputStream; | |
| import com.sun.star.lang.XComponent; | |
| import com.sun.star.lang.XMultiServiceFactory; | |
| import com.sun.star.uno.UnoRuntime; | |
| import com.sun.star.util.XCloseable; | |
| import com.sun.star.ucb.XSimpleFileAccess; | |
| import helper.URLHelper; | |
| import java.io.File; | |
| import java.io.InputStreamReader; | |
| import java.util.Enumeration; | |
| import java.util.Vector; | |
| // ---------- 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 org.openoffice.test.OfficeFileUrl; | |
| import static org.junit.Assert.*; | |
| // ------------------------------------------ | |
| //----------------------------------------------- | |
| /** @short Check the interface method XComponentLoader.loadComponentFromURL() | |
| @descr A prerequisite for this test is a server which allows access to files | |
| that will be loaded via three different access methods: | |
| <ul> | |
| <li>1. nfs (mounted directory / mapped network drive)</li> | |
| <li>2. ftp</li> | |
| <li>3. http</li> | |
| </ul> | |
| <p> | |
| The test will look for a list of files from the <i>TestDocumentPath</i> | |
| on and load these files from the mounted directory, via ftp and http. | |
| The parameters for this have to be "ftp_access" and "http_access". | |
| If they are not given, tests for ftp and http will fail. | |
| @todo We need a further test for accessing UNC paths on windows! | |
| */ | |
| public class CheckXComponentLoader | |
| { | |
| //------------------------------------------- | |
| // some const | |
| /** used to classify the result of a loadComponentFromURL() request. */ | |
| private static final int RESULT_UNKNOWN = 0; | |
| private static final int RESULT_VALID_DOC = 1; | |
| private static final int RESULT_EMPTY_DOC = 2; | |
| private static final int RESULT_ILLEGALARGUMENTEXCEPTION = 3; | |
| private static final int RESULT_IOEXCEPTION = 4; | |
| private static final int RESULT_RUNTIMEEXCEPTION = 5; | |
| private static final int RESULT_EXCEPTION = 6; | |
| /** File/URL separators. */ | |
| private static final String fs_url = "/"; | |
| // private static final String fs_sys = System.getProperty("file.separator"); | |
| /** used for testing password protected files. */ | |
| private static final String SUFFIX_PASSWORD_TEMPFILE = "password_"; | |
| private static final String PREFIX_PASSWORD_TEMPFILE = ".sxw"; | |
| private static final String DEFAULT_PASSWORD = "DefaultPasswordForComponentLoaderTest"; | |
| //------------------------------------------- | |
| // member | |
| /** points to the global uno service manager. */ | |
| private XMultiServiceFactory m_xMSF = null; | |
| /** provides XComponentLoader interface. */ | |
| private XFrame m_xDesktop = null; | |
| /** provides XComponentLoader interface too. */ | |
| private XFrame m_xFrame = null; | |
| /** will be set to xDesktop OR xFrame. */ | |
| private XComponentLoader m_xLoader = null; | |
| /** can be used to open local files as stream. */ | |
| private XSimpleFileAccess m_xStreamProvider = null; | |
| /** directory for creating temp. files. */ | |
| private String m_sTempPath = null; | |
| /** directory for searching files to load */ | |
| private String m_sTestDocPath = null; | |
| /** files of m_sTestDocPath to test. */ | |
| private static Vector m_lTestFiles = null; | |
| //------------------------------------------- | |
| // test environment | |
| //------------------------------------------- | |
| /** @short A function to tell the framework, | |
| which test functions are available. | |
| @return All test methods. | |
| @todo Think about selection of tests from outside ... | |
| */ | |
| // public String[] getTestMethodNames() | |
| // { | |
| // // TODO think about trigger of sub-tests from outside | |
| // return new String[] | |
| // { | |
| // "checkURLEncoding" , | |
| // "checkURLHandling" , | |
| // "checkUsingOfMediaDescriptor", | |
| // "checkStreamLoading" , | |
| // "checkLoadingWithPassword" | |
| // }; | |
| // } | |
| //------------------------------------------- | |
| /** @short Create the environment for following tests. | |
| @descr Use either a component loader from desktop or | |
| from frame | |
| */ | |
| @Before public void before() | |
| { | |
| // get uno service manager from global test environment | |
| m_xMSF = getMSF(); | |
| // create stream provider | |
| try | |
| { | |
| m_xStreamProvider = UnoRuntime.queryInterface(XSimpleFileAccess.class, m_xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess")); | |
| } | |
| catch(java.lang.Throwable ex) | |
| { | |
| fail("Could not create a stream provider instance."); | |
| } | |
| // create desktop instance | |
| try | |
| { | |
| m_xDesktop = UnoRuntime.queryInterface(XFrame.class, m_xMSF.createInstance("com.sun.star.frame.Desktop")); | |
| } | |
| catch(java.lang.Throwable ex) | |
| { | |
| fail("Could not create the desktop instance."); | |
| } | |
| // create frame instance | |
| m_xFrame = m_xDesktop.findFrame("testFrame_componentLoader", | |
| FrameSearchFlag.TASKS | FrameSearchFlag.CREATE); | |
| assertNotNull("Couldn't create test frame.", m_xFrame); | |
| // define default loader for testing | |
| // TODO think about using of bot loader instances! | |
| m_xLoader = UnoRuntime.queryInterface(XComponentLoader.class, m_xDesktop); | |
| assertNotNull("Desktop service doesn't support needed component loader interface.", m_xLoader); | |
| // get temp path for this environment | |
| final String tempDirURL = util.utils.getOfficeTemp/*Dir*/(getMSF()); | |
| m_sTempPath = graphical.FileHelper.getSystemPathFromFileURL(tempDirURL); | |
| // m_sTempPath = "."+fs_sys; | |
| // get all files from the given directory | |
| // TODO URLHelper should ignore directories! | |
| m_lTestFiles = new Vector(); | |
| final String sTestDocURL = OfficeFileUrl.getAbsolute(new File("testdocuments")); | |
| m_sTestDocPath = graphical.FileHelper.getSystemPathFromFileURL(sTestDocURL); | |
| try | |
| { | |
| File aBaseDir = new File(m_sTestDocPath); | |
| Vector lDirContent = URLHelper.getSystemFilesFromDir(aBaseDir.getPath()); | |
| Enumeration lList = lDirContent.elements(); | |
| int nBasePathLength = m_sTestDocPath.length(); | |
| while(lList.hasMoreElements()) | |
| { | |
| File aFile = (File)lList.nextElement(); | |
| // ignore broken links and directories at all | |
| if ( | |
| (!aFile.exists()) || | |
| (!aFile.isFile()) | |
| ) | |
| { | |
| continue; | |
| } | |
| String sCompletePath = aFile.getAbsolutePath(); | |
| String sSubPath = sCompletePath.substring(nBasePathLength); | |
| // Some test files are checked into CVS. ignore CVS helper files! | |
| // if (sSubPath.indexOf("CVS") > -1) | |
| // { | |
| // continue; | |
| // } | |
| m_lTestFiles.add(sSubPath); | |
| } | |
| } | |
| catch(java.lang.Throwable ex) | |
| { | |
| fail("Couldn't find test documents."); | |
| } | |
| } | |
| //------------------------------------------- | |
| /** @short close the environment. | |
| */ | |
| @After public void after() | |
| { | |
| XCloseable xClose = UnoRuntime.queryInterface(XCloseable.class, m_xFrame); | |
| try | |
| { | |
| xClose.close(false); | |
| } | |
| catch(com.sun.star.util.CloseVetoException exVeto) | |
| { fail("Test frame couldn't be closed successfully."); } | |
| m_xFrame = null; | |
| m_xLoader = null; | |
| } | |
| //------------------------------------------- | |
| /** @short Look for files in the given directory for loading. | |
| */ | |
| @Test public void checkUsingOfMediaDescriptor() | |
| { | |
| InteractionHandler xHandler = new InteractionHandler(); | |
| StatusIndicator xIndicator = new StatusIndicator(StatusIndicator.SHOWSTATUS_LOG); | |
| PropertyValue[] lProps = new PropertyValue[3]; | |
| lProps[0] = new PropertyValue(); | |
| lProps[0].Name = "Hidden"; | |
| lProps[0].Value = Boolean.TRUE; | |
| lProps[1] = new PropertyValue(); | |
| lProps[1].Name = "InteractionHandler"; | |
| lProps[1].Value = xHandler; | |
| lProps[2] = new PropertyValue(); | |
| lProps[2].Name = "StatusIndicator"; | |
| lProps[2].Value = xIndicator; | |
| Enumeration aSnapshot = m_lTestFiles.elements(); | |
| while (aSnapshot.hasMoreElements()) | |
| { | |
| File aSysFile = new File(m_sTestDocPath, (String)aSnapshot.nextElement()); | |
| String sURL = URLHelper.getFileURLFromSystemPath(aSysFile); | |
| if (/*! (sURL.endsWith(".jpg") || | |
| sURL.endsWith(".gif"))*/ | |
| true | |
| ) | |
| { | |
| loadURL(m_xLoader, RESULT_VALID_DOC, sURL, "_blank", 0, lProps); | |
| // It's not needed to reset this using states! | |
| // It's done internally ... | |
| if (!xIndicator.wasUsed()) | |
| { | |
| System.out.println("External progress was not used for loading."); | |
| } | |
| if (xHandler.wasUsed()) | |
| { | |
| System.out.println("External interaction handler was not used for loading."); | |
| } | |
| } | |
| } | |
| } | |
| //------------------------------------------- | |
| /** TODO document me and move this method to a more global helper! */ | |
| private String impl_getTempFileName(String sTempPath, | |
| String sSuffix , | |
| String sPrefix ) | |
| { | |
| File aDir = new File(sTempPath); | |
| aDir.mkdirs(); | |
| // if (!aDir.exists()) | |
| // { | |
| // fail("Could not access temp directory \"" + sTempPath + "\"."); | |
| // } | |
| // TODO: create a temp file which not exist! | |
| for (int i=0; i<999999; ++i) | |
| { | |
| File aTempFile = new File(aDir, sSuffix+i+sPrefix); | |
| if (!aTempFile.exists()) | |
| { | |
| return aTempFile.getAbsolutePath(); | |
| } | |
| } | |
| fail("Seems that all temp file names are currently in use!"); | |
| return null; | |
| } | |
| //------------------------------------------- | |
| /** TODO document me and move this method to a more global helper! */ | |
| private void impl_createTempOfficeDocument(XComponentLoader xLoader , | |
| String sSourceURL, | |
| String sTargetURL, | |
| String sFilter , | |
| String sPassword ) | |
| { | |
| PropertyValue[] lLoadProps = new PropertyValue[1]; | |
| lLoadProps[0] = new PropertyValue(); | |
| lLoadProps[0].Name = "Hidden"; | |
| lLoadProps[0].Value = Boolean.TRUE; | |
| PropertyValue[] lSaveProps = new PropertyValue[3]; | |
| lSaveProps[0] = new PropertyValue(); | |
| lSaveProps[0].Name = "FilterName"; | |
| lSaveProps[0].Value = sFilter; | |
| lSaveProps[1] = new PropertyValue(); | |
| lSaveProps[1].Name = "PassWord"; | |
| lSaveProps[1].Value = sPassword; | |
| lSaveProps[2] = new PropertyValue(); | |
| lSaveProps[2].Name = "Overwrite"; | |
| lSaveProps[2].Value = Boolean.TRUE; | |
| XComponent xDoc = null; | |
| try | |
| { | |
| // load it | |
| xDoc = xLoader.loadComponentFromURL(sSourceURL, "_blank", 0, lLoadProps); | |
| assertNotNull("Could create office document, which should be saved as temp one.", xDoc); | |
| // save it as temp file | |
| XStorable xStore = UnoRuntime.queryInterface(XStorable.class, xDoc); | |
| xStore.storeAsURL(sTargetURL, lSaveProps); | |
| // Dont forget to close this file. Otherwise the temp file is locked! | |
| XCloseable xClose = UnoRuntime.queryInterface(XCloseable.class, xDoc); | |
| xClose.close(false); | |
| } | |
| catch(java.lang.Throwable ex) | |
| { | |
| fail("Could not create temp office document."); | |
| } | |
| } | |
| //------------------------------------------- | |
| /** @short Check the password handling. | |
| @descr The used password is the one given | |
| as password for the ftp connection, | |
| or - if none given a default one. | |
| */ | |
| @Test public void checkLoadingWithPassword() | |
| { | |
| String sTempFile = impl_getTempFileName(m_sTempPath, SUFFIX_PASSWORD_TEMPFILE, PREFIX_PASSWORD_TEMPFILE); | |
| File aTestFile = new File(sTempFile); | |
| String sTestURL = URLHelper.getFileURLFromSystemPath(aTestFile); | |
| impl_createTempOfficeDocument(m_xLoader, "private:factory/swriter", sTestURL, "StarOffice XML (Writer)", DEFAULT_PASSWORD); | |
| PropertyValue[] lArgs1 = new PropertyValue[2]; | |
| lArgs1[0] = new PropertyValue(); | |
| lArgs1[0].Name = "Hidden"; | |
| lArgs1[0].Value = Boolean.TRUE; | |
| lArgs1[1] = new PropertyValue(); | |
| lArgs1[1].Name = "Password"; | |
| lArgs1[1].Value = DEFAULT_PASSWORD; | |
| PropertyValue[] lArgs2 = new PropertyValue[1]; | |
| lArgs2[0] = new PropertyValue(); | |
| lArgs2[0].Name = "Hidden"; | |
| lArgs2[0].Value = Boolean.TRUE; | |
| loadURL(m_xLoader, RESULT_VALID_DOC, sTestURL, "_blank", 0, lArgs1); | |
| // TODO: wrong? loadURL(m_xLoader, RESULT_EMPTY_DOC, sTestURL, "_blank", 0, lArgs2); | |
| } | |
| /** | |
| * Check URL encoding. The first filename that matches "*.sxw" | |
| * is used as source for several encodings. | |
| */ | |
| @Test public void checkURLEncoding() { | |
| PropertyValue[] lProps = new PropertyValue[1]; | |
| lProps[0] = new PropertyValue(); | |
| lProps[0].Name = "Hidden"; | |
| lProps[0].Value = Boolean.TRUE; | |
| // first get encoding of this system | |
| InputStreamReader in = new InputStreamReader(System.in); | |
| String sSystemEncoding = in.getEncoding(); | |
| System.out.println("This system's encoding: " + sSystemEncoding); | |
| assertNotNull("Found an empty directory. There are no files for testing.", m_lTestFiles); | |
| // get a file name as byte array | |
| Enumeration aSnapshot = m_lTestFiles.elements(); | |
| byte[] baURL = null; | |
| while (aSnapshot.hasMoreElements()) { | |
| File aFile = new File(m_sTestDocPath, (String)aSnapshot.nextElement()); | |
| String sFile = URLHelper.getFileURLFromSystemPath(aFile); | |
| // take the first sxw file as stream | |
| if (sFile.endsWith(".sxw")) { | |
| baURL = sFile.getBytes(); | |
| break; | |
| } | |
| } | |
| assertNotNull("Found no file to load. Cannot test.", baURL); | |
| //construct several different encoded strings | |
| String[] sEncoding = new String[] { | |
| "US-ASCII", "TRUE", // us ascii encoding | |
| "ISO-8859-1", "TRUE", // iso encoding | |
| "UTF-8", "TRUE", // 8 bit utf encoding | |
| "UTF-16BE", "FALSE", // 16 bit big endian utf | |
| "UTF-16LE", "FALSE", // 16 bit little endian utf | |
| "UTF-16", "FALSE" // 16 bit, order specified by byte order mark | |
| }; | |
| for (int i = 0; i < sEncoding.length; i = i + 2) { | |
| try { | |
| String encURL = new String(baURL, sEncoding[i]); | |
| System.out.println("ENC[" + sEncoding[i] + "]"); | |
| if (sEncoding[i + 1].equals("TRUE")) { | |
| loadURL(m_xLoader, RESULT_VALID_DOC, encURL, "_blank", 0, | |
| lProps); | |
| } else { | |
| //with cws_loadenv01 changed to IllegalArgumentException | |
| loadURL(m_xLoader, RESULT_ILLEGALARGUMENTEXCEPTION, encURL, "_blank", 0, | |
| lProps); | |
| } | |
| } catch (java.io.UnsupportedEncodingException e) { | |
| fail("Unsopported Encoding: " + sEncoding[i] + | |
| "\n Not able to test encoding on this platform."); | |
| } | |
| } | |
| } | |
| /** | |
| * Check url handling with a load of URLs. | |
| * 1. unsupported URLs. | |
| * 2. "stupid" URLs | |
| * 3. case sensitive URLs | |
| * 4. FTP URLs | |
| * 5. HTTP URLs | |
| */ | |
| // public void checkURLHandling() { | |
| // PropertyValue[] lProps = new PropertyValue[1]; | |
| // | |
| // lProps[0] = new PropertyValue(); | |
| // lProps[0].Name = "Hidden"; | |
| // lProps[0].Value = Boolean.TRUE; | |
| // | |
| // System.out.println("check possible but unsupported URLs"); | |
| // | |
| // String[] sIllegalArgs = new String[] { | |
| // "slot:5000", "slot:10909", ".uno:SaveAs", ".uno:Open", | |
| // }; | |
| // loadURL(m_xLoader, RESULT_ILLEGALARGUMENTEXCEPTION, sIllegalArgs, | |
| // "_blank", 0, lProps); | |
| // | |
| // System.out.println("check stupid URLs"); | |
| // | |
| // sIllegalArgs = new String[] { | |
| // "slot:xxx", "slot:111111111", ".uno:save_as", ".uno:open_this", | |
| // ".UnO:*", | |
| // }; | |
| // loadURL(m_xLoader, RESULT_ILLEGALARGUMENTEXCEPTION, sIllegalArgs, | |
| // "_blank", 0, lProps); | |
| // | |
| // String[] sEmptyDocs = new String[] { | |
| // "mailo:hansi.meier@germany.sun.com", "file:/c:\\test/file.cxx", | |
| // "file:///c|:\\test/file.cxx", "http_server://staroffice-doc\\", | |
| // "c:\\\\test///\\test.sxw", "news_:staroffice-doc", | |
| // "newsletter@blubber", "private_factory/swriter", | |
| // "private:factory//swriter", "private:factory/swriter/___", | |
| // "c:\\test\\test.sxw", "macro:///ImportWizard.Main.Main", | |
| // "macro:///Euro.AutoPilotRun.StartAutoPilot", | |
| // "service:com.sun.star.frame.Frame", | |
| // "mailto:steffen.grund@germany.sun.com", "news:staroffice-doc", | |
| // "macro:/ExportWizard", "macro://Euro.AutoPilotRun.StartAutoPilot", | |
| // "service:com.sun.star.frame." | |
| // }; | |
| // | |
| // //with cws_loadenv01 changed to IllegalArgumentException | |
| // loadURL(m_xLoader, RESULT_ILLEGALARGUMENTEXCEPTION, sEmptyDocs, "_blank", 0, | |
| // lProps); | |
| // | |
| // System.out.println("check case sensitive URLs"); | |
| // | |
| // sIllegalArgs = new String[] { | |
| // "sLot:5000", "sloT:10909", ".unO:SaveAs", ".uno:OPEN", | |
| // }; | |
| // loadURL(m_xLoader, RESULT_ILLEGALARGUMENTEXCEPTION, sIllegalArgs, | |
| // "_blank", 0, lProps); | |
| // | |
| // sEmptyDocs = new String[] { | |
| // "private:factory/SWRITER", "private:factory/SWRITER/WEB", | |
| // "macro:///importwizard.main.main", | |
| // "Macro:///euro.autopilotrun.startautopilot", | |
| // "Service:Com.Sun.Star.Frame.Frame", | |
| // "Mailto:andreas.schluens@germany.sun.com", "neWs:staroffice-doc", | |
| // "News:Staroffice-doc" | |
| // }; | |
| // | |
| // //with cws_loadenv01 changed to IllegalArgumentException | |
| // loadURL(m_xLoader, RESULT_ILLEGALARGUMENTEXCEPTION, sEmptyDocs, "_blank", 0, | |
| // lProps); | |
| // | |
| // System.out.println("check FTP URLs"); | |
| // | |
| // String sFTPURL = (String) param.get("FtpAccess"); | |
| // Enumeration aSnapshot = m_lTestFiles.elements(); | |
| // | |
| // while (aSnapshot.hasMoreElements()) { | |
| // String doc = (String) aSnapshot.nextElement(); | |
| // | |
| // | |
| // // if os is windows | |
| // doc = doc.replace('\\', '/'); | |
| // if (doc.indexOf("CVS")<0) { | |
| // loadURL(m_xLoader, RESULT_VALID_DOC, sFTPURL + "/" + doc, | |
| // "_blank", 0, lProps); | |
| // } | |
| // } | |
| // | |
| // System.out.println("check HTTP URLs"); | |
| // | |
| // String sHTTPURL = (String) param.get("HttpAccess"); | |
| // aSnapshot = m_lTestFiles.elements(); | |
| // | |
| // while (aSnapshot.hasMoreElements()) { | |
| // String doc = (String) aSnapshot.nextElement(); | |
| // | |
| // | |
| // // if os is windows | |
| // doc = doc.replace('\\', '/'); | |
| // if (doc.indexOf("CVS")<0) { | |
| // loadURL(m_xLoader, RESULT_VALID_DOC, sHTTPURL + "/" + doc, | |
| // "_blank", 0, lProps); | |
| // } | |
| // } | |
| // } | |
| /** TODo document me | |
| */ | |
| @Test public void checkStreamLoading() | |
| { | |
| PropertyValue[] lProps = new PropertyValue[2]; | |
| lProps[0] = new PropertyValue(); | |
| lProps[0].Name = "Hidden"; | |
| lProps[0].Value = Boolean.TRUE; | |
| lProps[1] = new PropertyValue(); | |
| lProps[1].Name = "InputStream"; | |
| Enumeration aSnapshot = m_lTestFiles.elements(); | |
| while (aSnapshot.hasMoreElements()) | |
| { | |
| File aFile = new File(m_sTestDocPath, (String) aSnapshot.nextElement()); | |
| String sURL = URLHelper.getFileURLFromSystemPath(aFile); | |
| // if (sURL.indexOf("CVS") > -1) | |
| // { | |
| // continue; | |
| // } | |
| try | |
| { | |
| XInputStream xStream = m_xStreamProvider.openFileRead(sURL); | |
| lProps[1].Value = xStream; | |
| } | |
| catch(com.sun.star.uno.Exception e) | |
| { | |
| fail("Could not open test file \""+sURL+"\" for stream test."); | |
| } | |
| // check different version of "private:stream" URL! | |
| loadURL(m_xLoader, RESULT_VALID_DOC, "private:stream" , "_blank", 0, lProps); | |
| // loadURL(m_xLoader, RESULT_VALID_DOC, "private:stream" , "_blank", 0, lProps); | |
| // loadURL(m_xLoader, RESULT_VALID_DOC, "private:stream/", "_blank", 0, lProps); | |
| } | |
| } | |
| /** | |
| * Loads one URL with the given parameters using the method | |
| * loadComponentFromURL(). Further it's possible to specify, whch result is | |
| * required and we check internally if it was reached. Logging of errors | |
| * and success stories is done inside this method too. Of course we catch | |
| * all possible exceptions and try to leave the office without any forgotten | |
| * but opened documents. | |
| */ | |
| private void loadURL(XComponentLoader m_xLoader, int nRequiredResult, | |
| String sURL, String sTarget, int nFlags, | |
| PropertyValue[] lProps) { | |
| int nResult = RESULT_EMPTY_DOC; | |
| XComponent xDoc = null; | |
| try { | |
| xDoc = m_xLoader.loadComponentFromURL(sURL, sTarget, nFlags, | |
| lProps); | |
| if (xDoc != null) { | |
| nResult = RESULT_VALID_DOC; | |
| } else { | |
| nResult = RESULT_EMPTY_DOC; | |
| } | |
| } catch (com.sun.star.lang.IllegalArgumentException exArgument) { | |
| nResult = RESULT_ILLEGALARGUMENTEXCEPTION; | |
| } catch (com.sun.star.io.IOException exIO) { | |
| nResult = RESULT_IOEXCEPTION; | |
| } catch (com.sun.star.uno.RuntimeException exRuntime) { | |
| nResult = RESULT_RUNTIMEEXCEPTION; | |
| } catch (Exception e) { | |
| nResult = RESULT_EXCEPTION; | |
| } | |
| try { | |
| if (xDoc != null) { | |
| xDoc.dispose(); | |
| xDoc = null; | |
| } | |
| } catch (com.sun.star.uno.RuntimeException exClosing) { | |
| System.out.println("exception during disposing of a document found!" + | |
| " Doesn't influence test - but should be checked."); | |
| } | |
| String sMessage = "URL[\"" + sURL + "\"]"; | |
| if (nResult == nRequiredResult) { | |
| System.out.println(sMessage + " expected result [" + | |
| convertResult2String(nResult) + "] "); | |
| } else { | |
| fail(sMessage + " unexpected result [" + | |
| convertResult2String(nResult) + "] " + | |
| "\nrequired was [" + | |
| convertResult2String(nRequiredResult) + "]" + | |
| "\nwe got [" + convertResult2String(nResult) + "]" | |
| ); | |
| } | |
| } | |
| private void loadURL(XComponentLoader m_xLoader, int nRequiredResult, | |
| String[] sURL, String sTarget, int nFlags, | |
| PropertyValue[] lProps) { | |
| for (int i = 0; i < sURL.length; i++) | |
| { | |
| loadURL(m_xLoader, nRequiredResult, sURL[i], sTarget, nFlags, lProps); | |
| } | |
| } | |
| /** | |
| * it match the int result value to a string, which can be used for logging | |
| */ | |
| private static String convertResult2String(int nResult) { | |
| switch (nResult) { | |
| case RESULT_VALID_DOC: | |
| return "VALID_DOC"; | |
| case RESULT_EMPTY_DOC: | |
| return "EMPTY_DOC"; | |
| case RESULT_ILLEGALARGUMENTEXCEPTION: | |
| return "ILLEGALARGUMENTEXCEPTION"; | |
| case RESULT_IOEXCEPTION: | |
| return "IOEXCEPTION"; | |
| case RESULT_RUNTIMEEXCEPTION: | |
| return "RUNTIMEEXCEPTION"; | |
| case RESULT_EXCEPTION: | |
| return "ALLOTHEREXCEPTION"; | |
| } | |
| return "unknown!"; | |
| } | |
| 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(); | |
| } |