| /************************************************************** |
| * |
| * 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 requirments: |
| * 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 neccesarry 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 don not have such a user tree. The office will create it on its first start, |
| * but this will take some time. |
| * Note: This funktionality 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("couldnot get ServiceFarcotry", 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 contains more the one project. This methods translates given project paramater to the |
| * correspind 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 "famework,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("mached 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 foldres 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 wirte 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; |
| // } |
| // } |
| } |