/**************************************************************
 * 
 * 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 pathes 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 doesnt 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);
                // Its not needed to reset this using states!
                // Its done internaly ...
                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 senstive 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();

}