xref: /AOO42X/main/qadevOOo/tests/java/complex/unoapi/CheckModuleAPI.java (revision 850627aea5051aeeadcec55420dcd716dc66f0c8)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



/** complex tests to check the UNO-API
 **/
package complex.unoapi;

// imports
import base.java_complex;
import complexlib.ComplexTestCase;
import helper.OfficeProvider;
import helper.ParameterNotFoundException;
import helper.ProcessHandler;
import com.sun.star.lang.XMultiServiceFactory;
import helper.BuildEnvTools;
import helper.ComplexDescGetter;
import helper.CwsDataExchangeImpl;
import java.io.File;
// import java.io.FileFilter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import share.DescEntry;
import util.PropertyName;
import util.utils;

/**
 * This Complex Test will test the UNO-API by calling dmake in <B>$MODULE</B>/qa/unoapi<p>
 * This test depends on some requirements:
 * The <B>TestJob</B> is <b>-o complex.unoapi.CheckModuleAPI::module(<CODE>MODULE</CODE>)</b><p> where <CODE>MODULE</CODE>
 * could be the following:<p>
 * <ul>
 *  <li><b>all</b>  iterates over <CODE>SRC_ROOT</CODE> and call <CODE>dmake</CODE> in all qa/unoapi folder</li><p>
 *  <li><b>$module</b>  call dmake in $module/qa/unoapi folder</li><p>
 *  <li><b>$module1,$module2,...</b>    call dmake in $module1/qa/unoapi folder then in $module2/qa/unoapi folder and so on</li><p>
 * </ul><p>
 *
 * Also you have to fill the following parameter:
 * <ul>
 *  <li><b>SHELL</b>:      fill this parameter with a shell</li>
 * </ul>
 *
 */
public class CheckModuleAPI extends ComplexTestCase
{

    private static String mSRC_ROOT = null;
    private static boolean mIsInitialized = false;
    private final static boolean mContinue = true;
    private static boolean mDebug = false;
    private static BuildEnvTools bet = null;

    /**
     * Initialize the test environment.
     * This method checks for all necessary parameter and exit if not all parameter are set.
     *
     * Further this method starts an office instance and gets the office some more time to start. This is because
     * some freshly installed offices do not have such a user tree. The office will create it on its first start,
     * but this will take some time.
     * Note: This functionality is only reasonable with parameter <CODE>-noOffice true</CODE>
     */
    public void before()
    {

        if (!mIsInitialized)
        {
            mIsInitialized = true;

            try
            {

                bet = new BuildEnvTools(param, log);

            }
            catch (ParameterNotFoundException ex)
            {
                this.failed(ex.toString(), false);
            }

            mSRC_ROOT = bet.getSrcRoot();

            mDebug = param.getBool(PropertyName.DEBUG_IS_ACTIVE);

        }
    }

    /**
     * let API tests run.
     * @param module
     */
    public void checkModule(String module)
    {
        log.println(utils.getDateTime() + ": start testing module '" + module + "'");

        log.println(utils.getDateTime() + "start new Office instance...");

        // TODO: is Office started with this program?
        final OfficeProvider officeProvider = new OfficeProvider();

        log.println(utils.getDateTime() + "Receiving the ServiceManager of the Office ");
        final XMultiServiceFactory msf = (XMultiServiceFactory) officeProvider.getManager(param);
        assure("could not get ServiceFactory", msf != null, mContinue);
        param.put("ServiceFactory", msf);

        final String sep = System.getProperty("file.separator");
        final String sUnoapi = getModulePath(module);
        final File fUnoapi = new File(sUnoapi);
        final String sMakeFile = sUnoapi + sep + "makefile.mk";
        final File fMakeFile = new File(sMakeFile);
        assure("ERROR: could not find makefile: '" + sMakeFile + "'", fMakeFile.exists(), mContinue);

        final String[] commands = getDmakeCommands(sUnoapi);

        final ProcessHandler procHdl = bet.runCommandsInEnvironmentShell(commands, fUnoapi, 0);
        log.println("exit code of dmake: " + procHdl.getExitCode());
        String test = procHdl.getOutputText();
        test += procHdl.getErrorText();
//        if (mDebug) {
//            log.println("---> Output of dmake:");
//            log.println(procHdl.getOutputText());
//            log.println("<--- Output of dmake:");
//            log.println("---> Error output of dmake:");
//            log.println(procHdl.getErrorText());
//            log.println("<--- Error output of dmake:");
//        }
        assure("module '" + module + "' failed", verifyOutput(test), mContinue);
        log.println(utils.getDateTime() + " module '" + module + "': kill existing office...");

        // TODO: how to check if the office is not started with this process.
        boolean bNoOffice = param.getBool("NoOffice");
        if (!bNoOffice)
        {
            try
            {
                officeProvider.closeExistingOffice(param, true);
            }
            catch (java.lang.UnsatisfiedLinkError exception)
            {
                log.println("Office seems not to be running");
            }
        }
    }
    private String getQaUnoApiPath(String srcRoot, String _sModul)
    {
        File aFile = new File(srcRoot);
        if (!aFile.exists())
        {
            System.out.println("ERROR: srcRoot '" + srcRoot + "' does not exist.");
            return null;
        }
        String sModulePath = srcRoot;
        sModulePath += File.separator;
        sModulePath += _sModul;

        File aModulePath = new File(sModulePath);
        if (! aModulePath.exists())
        {
            aModulePath = new File(sModulePath + ".lnk");
            if (! aModulePath.exists())
            {
                aModulePath = new File(sModulePath + ".link");
                if (! aModulePath.exists())
                {
                    // module does not exist.
                    return null;
                }
            }
        }
        sModulePath = aModulePath.getAbsolutePath();
        sModulePath += File.separator;
        sModulePath += "qa";
        sModulePath += File.separator;
        sModulePath += "unoapi";
        File aModulePathQaUnoApi = new File(sModulePath);
        if (aModulePathQaUnoApi.exists())
        {
            return aModulePathQaUnoApi.getAbsolutePath();
        }
        return null;
    }
    private boolean doesQaUnoApiFolderExist(String srcRoot, String _sModul)
    {
        if (getQaUnoApiPath(srcRoot, _sModul) != null)
        {
            return true;
        }
        return false;
    }
/*
 private boolean doesQaUnoApiFolderExist(File srcRoot)
    {
        final FolderFilter qaFilter = new FolderFilter("qa");
        final File[] qaTree = srcRoot.listFiles(qaFilter);
        if (qaTree != null)
        {
            for (int j = 0; j < qaTree.length; j++)
            {
                final File qaFolder = qaTree[j];
                final FolderFilter apiFilter = new FolderFilter("unoapi");
                final File[] apiTree = qaFolder.listFiles(apiFilter);
                if (apiTree != null && apiTree.length > 0)
                {
                    return true;
                }
            }
        }
        return false;
    }
*/

    private String[] getAllModuleCommand()
    {
        String[] checkModules;

        final String[] names = getModulesFromSourceRoot();
        checkModules = getCheckModuleCommand(names);

        return checkModules;
    }

    private String[] getCheckModuleCommand(String[] names)
    {
        String[] checkModules;
        checkModules = new String[names.length];

        for (int i = 0; i < names.length; i++)
        {
            // if a module is not added to a cws it contains a dot in its name (forms.lnk)
            if (names[i].indexOf(".") != -1)
            {
                checkModules[i] = "checkModule(" + names[i].substring(0, names[i].indexOf(".")) + ")";
            }
            else
            {
                checkModules[i] = "checkModule(" + names[i] + ")";
            }
        }
        return checkModules;
    }

    private String[] getDmakeCommands(String sUnoapi)
    {

        String[] cmdLines = null;
        final String platform = (String) param.get(PropertyName.OPERATING_SYSTEM);
        log.println("prepare command for platform " + platform);

        if (platform.equals(PropertyName.WNTMSCI))
        {
            if (param.getBool(PropertyName.CYGWIN))
            {
                // cygwin stuff
                cmdLines = new String[]
                        {
                            "cd `cygpath '" + sUnoapi.replaceAll("\\\\", "\\\\\\\\") + "'`",
                            "dmake"
                        };
            }
            else
            {
                // old 4NT
                cmdLines = new String[]
                        {
                            "cdd " + sUnoapi,
                            "dmake"
                        };
            }
        }
        else
        {
            // unix
            cmdLines = new String[]
                    {
                        "cd " + sUnoapi,
                        "dmake"
                    };
        }
        return cmdLines;
    }

    private String[] getCwsModuleCommand()
    {
        String[] checkModules;
        final String version = (String) param.get(PropertyName.VERSION);
        String[] names = null;
        if (version.startsWith("cws_"))
        {
            try
            {
                // cws version: all added modules must be tested
                final String cws = version.substring(4, version.length());
                final CwsDataExchangeImpl cde = new CwsDataExchangeImpl(cws, param, log);
                final ArrayList addedModules = cde.getModules();

                final ArrayList moduleNames = new ArrayList();
                Iterator iterator = addedModules.iterator();
                while (iterator.hasNext())
                {
                    String sModuleName = (String) iterator.next();
                    // String sFilename = mSRC_ROOT; //  + File.separator + sModuleName;
                    // final File sourceRoot = new File(sFilename);
                    if (doesQaUnoApiFolderExist(mSRC_ROOT, sModuleName))
                    {
                        moduleNames.add(sModuleName);
                    }
                }
                names = (String[]) moduleNames.toArray(new String[0]);
            }
            catch (ParameterNotFoundException ex)
            {
                this.failed(ex.toString(), false);
            }


        }
        else
        {
            // major version: all modules must be tested
            names = getModulesFromSourceRoot();
        }
        checkModules = getCheckModuleCommand(names);

        return checkModules;
    }

    private String[] getDefinedModuleCommand(String module)
    {
        String[] checkModules = null;
        // list of modules to test: (sw,sc,sd)
        if (module.indexOf(",") != -1)
        {
            final String[] names = module.split(",");
            checkModules = new String[names.length];
            for (int i = 0; i < names.length; i++)
            {
                final String moduleName = names[i].trim();

//                File sourceRoot = new File(mSRC_ROOT + File.separator + moduleName);
//                if (!sourceRoot.exists())
//                {
//                    sourceRoot = new File(mSRC_ROOT + File.separator + moduleName + ".lnk");
//                }

                if (doesQaUnoApiFolderExist(mSRC_ROOT, moduleName))
                {
                    checkModules[i] = "checkModule(" + moduleName + ")";
                }
            }
        }
        else
        {
//            File sourceRoot = new File(mSRC_ROOT + File.separator + module);
//            if (!sourceRoot.exists())
//            {
//                sourceRoot = new File(mSRC_ROOT + File.separator + module + ".lnk");
//            }
            if (doesQaUnoApiFolderExist(mSRC_ROOT, module))
            {
                checkModules = new String[]
                        {
                            "checkModule(" + module + ")"
                        };
            }
        }
        return checkModules;
    }

    private String getModulePath(String module)
    {

        // String sUnoapi = null;
        // final String sep = System.getProperty("file.separator");
        // final File srcRoot = new File(mSRC_ROOT);

        // final FolderFilter qaFilter = new FolderFilter(module);
        // final File[] moduleTree = srcRoot.listFiles(qaFilter);
//        if (moduleTree != null)
//        {
//            if (mDebug)
//            {
//                log.println("moduleTree length:" + moduleTree.length);
//                log.println("moduleTree: " + moduleTree[0].getAbsolutePath());
//            }
//            if (moduleTree != null)
//            {
//                sUnoapi = moduleTree[0].getAbsolutePath() + sep + "qa" + sep + "unoapi";
//            }
//        }
        String sUnoapi = getQaUnoApiPath(mSRC_ROOT, module);
        return sUnoapi;
    }

    /**
    Some modules contain more than one project. This method translates given project parameter to the
     *  corresponding module name.
     *
     * fwk -> framework
     * fwl -> framework
     * sch -> chart2
     * lnn -> lingu
     * lng -> linguistic
     * sfx -> sfx2
     * sm -> starmath
     */
    private String getTranslatedNames(String module)
    {

        final HashMap aModuleHashMap = new HashMap();

        aModuleHashMap.put("fwk", "framework");
        aModuleHashMap.put("fwl", "framework");
        aModuleHashMap.put("sch", "chart2");
        aModuleHashMap.put("lnn", "lingu");
        aModuleHashMap.put("lng", "linguistic");
        aModuleHashMap.put("sfx", "sfx2");
        aModuleHashMap.put("sm", "starmath");

        // it could the that the parameter looks like "fwk,fwl". This results in double "framework,framework".
        // The following loop correct this to only one "framework"

        final Set keys = aModuleHashMap.keySet();
        final Iterator iterator = keys.iterator();
        while (iterator.hasNext())
        {

            final String key = (String) iterator.next();
            final String value = (String) aModuleHashMap.get(key);

            module = module.replaceAll(key, value);

            final int count = module.split(value).length;
            if (count > 2)
            {
                for (int i = 2; i < count; i++)
                {
                    module.replaceFirst("," + value, "");
                }

            }
        }
        return module;
    }

    private boolean verifyOutput(String output)
    {

        log.println("verify output...");
        boolean ok = false;
        final String[] outs = output.split("\n");

        for (int i = 0; i < outs.length; i++)
        {
            final String line = outs[i];
            if (line.matches("[0-9]+? of [0-9]+? tests failed"))
            {
                log.println("matched line: " + line);
                if (line.matches("0 of [0-9]+? tests failed"))
                {
                    ok = true;
                    log.println("Module passed OK");
                }
                else
                {
                    log.println("Module passed FAILED");
                }
            }
        }

        if (!ok)
        {
            log.println("ERROR: could not find '0 of [0-9]+? tests failed' in output");
        }

        return ok;
    }

    private String[] getModulesFromSourceRoot()
    {
        log.println("**** run module tests over all modules ****");

        log.println("search for qa/unoapi folders in all modules based in ");
        log.println("'" + mSRC_ROOT + "'");

        final ArrayList moduleNames = new ArrayList();
        final File sourceRoot = new File(mSRC_ROOT);
        final File[] sourceTree = sourceRoot.listFiles();

//        assure("Could not find any files in SOURCE_ROOT=" + mSRC_ROOT, sourceTree != null, false);

        for (int i = 0; i < sourceTree.length; i++)
        {
            final File moduleName = sourceTree[i];
            String sModuleName = moduleName.getName(); // (String)moduleNames.get(i);
            if (doesQaUnoApiFolderExist(mSRC_ROOT, sModuleName))
            {
                // addIfQaUnoApiFolderExist(moduleName, moduleNames);
                moduleNames.add(sModuleName);
            }
        }

        final String[] names = (String[]) moduleNames.toArray(new String[0]);
        return names;
    }

    /**
     * This function generates a list of modules to test and call <CODE>checkModule</CODE> for every module.
     * <p>
     *
     * @param module names to test. This could be
     * <ul>
     * <li>a comma separated list of modules like 'sw,sc,sd'</li>
     * <li>'all' to test all modules </li>
     * <li>'auto' to check only modules which are added to the ChildWorkSpace</li>
     * </ul>
     */
    public void module(String module)
    {

        String[] checkModules;
        final ComplexDescGetter desc = new ComplexDescGetter();
        DescEntry entry = null;
        module = module.trim();

        /*
        all: check all modules which contains a qa/unoapi folder
        auto: check all modules which contains a qa/unoapi folder except the module is not added
         */
        if (module.equals("all"))
        {
            checkModules = getAllModuleCommand();
        }
        else if (module.equals("auto"))
        {
            checkModules = getCwsModuleCommand();
        }
        else
        {
            module = getTranslatedNames(module);
            checkModules = getDefinedModuleCommand(module);
        }

        if (checkModules != null && checkModules.length > 0)
        {

            entry = desc.createTestDesc("complex.unoapi.CheckModuleAPI", "complex.unoapi.CheckModuleAPI", checkModules,
                    log);

            final java_complex complex = new java_complex();

            log.println("********** start test *************");
            final boolean result = complex.executeTest(param, new DescEntry[] { entry });
            log.println("********** end test *************");

            assure("CheckModuleAPI.module(" + module + ") PASSED.FAILED", result);

        }
        else
        {
            log.println("No modules containing qa/unoapi folder found => OK");
            state = true;
        }

        setUnoApiCwsStatus(state);

    }

    private void setUnoApiCwsStatus(boolean status)
    {

        if (!param.getBool(PropertyName.NO_CWS_ATTACH))
        {

            final String version = (String) param.get(PropertyName.VERSION);
            if (version.startsWith("cws_"))
            {
                try
                {

                    // cws version: all added modules must be tested
                    final String cws = version.substring(4, version.length());
                    final CwsDataExchangeImpl cde = new CwsDataExchangeImpl(cws, param, log);
                    cde.setUnoApiCwsStatus(status);
                }
                catch (ParameterNotFoundException ex)
                {
                    log.println("ERROR: could not write status to EIS database: " + ex.toString());
                }
            }
        }
    }

    public String[] getTestMethodNames()
    {
        return new String[]
                {
                    "module(all)"
                };
    }

//    class _FolderFilter implements FileFilter
//    {
//
//        private String mFolderName;
//
//        public FolderFilter(String folderName)
//        {
//            mFolderName = folderName;
//        }
//
//        public boolean accept_(File pathname)
//        {
//
//            boolean found = false;
//            if (pathname.isDirectory())
//            {
//                if (pathname.getName().equals(mFolderName))
//                {
//                    found = true;
//                }
//                else if (pathname.getName().equals(mFolderName + ".lnk"))
//                {
//                    found = true;
//                }
//            }
//            return found;
//        }
//    }
}