diff options
Diffstat (limited to 'qadevOOo/runner/helper/APIDescGetter.java')
| -rw-r--r-- | qadevOOo/runner/helper/APIDescGetter.java | 970 |
1 files changed, 970 insertions, 0 deletions
diff --git a/qadevOOo/runner/helper/APIDescGetter.java b/qadevOOo/runner/helper/APIDescGetter.java new file mode 100644 index 000000000..65f8da05c --- /dev/null +++ b/qadevOOo/runner/helper/APIDescGetter.java @@ -0,0 +1,970 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +package helper; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Collections; +import java.util.StringTokenizer; +import java.util.jar.JarEntry; + +import share.DescEntry; +import share.DescGetter; + +/** + * This is the Office-API specific DescGetter<br> + * <br> + * Examples:<br><br> + * -o sw.SwXBodyText<br> + * runs the module test of <B>Sw.SwXBodyText</B><br> + * <br> + * -o sw.SwXBodyText::com::sun::star::text::Text<br> + * runs only the interface test <B>com.sun.star.textText</B> of the module <B>Sw.SwXBodyText</B><br> + * <br> + * -o sw.SwXBodyText::com::sun::star::text::Text,com::sun::star::text::XSimpleText<br> + * runs only the interfaces test <B>com.sun.star.textText</B> and <B>com.sun.star.text.XSimpleText</B> of the module <B>Sw.SwXBodyText</B><br> + * <br> + * -p sw<br> + * runs all modules of the project <B>sw</B><br> + * <br> + * -p listall<br> + * lists all known module tests<br> + * <br> + * -sce SCENARIO_FILE<br> + * A scenario file is a property file which could contain <B>-o</B> and <B>-p</B> properties<br> + * <br> + * -sce sw.SwXBodyText,sw.SwXBookmark<br> + * runs the module test of <B>Sw.SwXBodyText</B> and <B>sw.SwXBookmark</B><br> + */ +public class APIDescGetter extends DescGetter +{ + + private static String fullJob = null; + + /* + * gets the needed information about a StarOffice component + * @param descPath Path to the ComponentDescription + * @param entry contains the entry name, e.g. sw.SwXBodyText + * @param debug if true some debug information is displayed on standard out + */ + @Override + public DescEntry[] getDescriptionFor(String job, String descPath, + boolean debug) + { + + if (job.startsWith("-o")) + { + job = job.substring(3, job.length()).trim(); + + if (job.indexOf('.') < 0) + { + return null; + } + + // special in case several Interfaces are given comma separated + if (job.indexOf(',') < 0) + { + DescEntry entry = getDescriptionForSingleJob(job, descPath, + debug); + + if (entry != null) + { + return new DescEntry[] + { + entry + }; + } + else + { + return null; + } + } + else + { + ArrayList<String> subs = getSubInterfaces(job); + String partjob = job.substring(0, job.indexOf(',')).trim(); + DescEntry entry = getDescriptionForSingleJob(partjob, descPath, + debug); + + if (entry != null) + { + for (int i = 0; i < entry.SubEntryCount; i++) + { + String subEntry = entry.SubEntries[i].longName; + int cpLength = entry.longName.length(); + subEntry = subEntry.substring(cpLength + 2, + subEntry.length()); + + if (subs.contains(subEntry)) + { + entry.SubEntries[i].isToTest = true; + } + } + + return new DescEntry[] + { + entry + }; + } + else + { + return null; + } + } + } + + if (job.startsWith("-p")) + { + job = job.substring(3, job.length()).trim(); + + String[] scenario = createScenario(descPath, job, debug); + if (scenario == null) + { + return null; + } + DescEntry[] entries = new DescEntry[scenario.length]; + for (int i = 0; i < scenario.length; i++) + { + entries[i] = getDescriptionForSingleJob( + scenario[i].substring(3).trim(), descPath, debug); + } + if (job.equals("listall")) + { + util.dbg.printArray(scenario); + System.exit(0); + } + return entries; + } + + if (job.startsWith("-sce")) + { + job = job.substring(5, job.length()).trim(); + + File sceFile = new File(job); + if (sceFile.exists()) + { + return getScenario(job, descPath, debug); + } + else + { + //look the scenario like this? : + // sw.SwXBodyText,sw.SwXTextCursor + ArrayList<String> subs = getSubObjects(job); + DescEntry[] entries = new DescEntry[subs.size()]; + + for (int i = 0; i < subs.size(); i++) + { + entries[i] = getDescriptionForSingleJob( + subs.get(i), descPath, debug); + } + return entries; + } + } + else + { + return null; + } + } + + @Override + protected DescEntry getDescriptionForSingleJob(String job, String descPath, + boolean debug) + { + boolean isSingleInterface = job.indexOf("::") > 0; + fullJob = job; + + if (isSingleInterface) + { + job = job.substring(0, job.indexOf("::")); + } + + if (job.startsWith("bugs")) + { + DescEntry Entry = new DescEntry(); + Entry.entryName = job; + Entry.longName = job; + Entry.EntryType = "bugdoc"; + Entry.isOptional = false; + Entry.isToTest = true; + Entry.SubEntryCount = 0; + Entry.hasErrorMsg = false; + Entry.State = "non possible"; + + return Entry; + } + + DescEntry entry = null; + + if (descPath != null) + { + if (debug) + { + System.out.println("## reading from File " + descPath); + } + + entry = getFromDirectory(descPath, job, debug); + } + else + { + if (debug) + { + System.out.println("## reading from jar"); + } + + entry = getFromClassPath(job); + } + + boolean foundInterface = false; + + if (isSingleInterface && (entry != null)) + { + for (int i = 0; i < entry.SubEntryCount; i++) + { + if (!(entry.SubEntries[i].longName).equals(fullJob)) + { + entry.SubEntries[i].isToTest = false; + } + else + { + foundInterface = true; + entry.SubEntries[i].isToTest = true; + } + } + } + + if (isSingleInterface && !foundInterface || entry == null) + { + return setErrorDescription(entry, + "couldn't find a description for test '" + fullJob + "'"); + } + + return entry; + } + + private static DescEntry[] getSubEntries(BufferedReader cvsFile, + DescEntry parent) + { + String line = ""; + String old_ifc_name = ""; + ArrayList<DescEntry> ifc_names = new ArrayList<DescEntry>(); + ArrayList<DescEntry> meth_names = new ArrayList<DescEntry>(); + DescEntry ifcDesc = null; + + while (line != null) + { + try + { + line = cvsFile.readLine(); + if (line == null) + { + continue; + } + if (line.startsWith("#")) + { + continue; + } + if (line.length() <= 0) + { + continue; + } +// TODO Problem here + + String ifc_name = ""; // = line.substring(line.indexOf(";") + 2, line.lastIndexOf(";") - 1); + String meth_name = ""; // = line.substring(line.lastIndexOf(";") + 2, line.length() - 1); + StringTokenizer aToken = new StringTokenizer(line, ";"); + if (aToken.countTokens() < 3) + { + System.out.println("Wrong format: Line '" + line + "' is not supported."); + continue; + } + if (aToken.hasMoreTokens()) + { + aToken.nextToken(); + } + if (aToken.hasMoreTokens()) + { + ifc_name = StringHelper.removeQuoteIfExists(aToken.nextToken()); + } + if (aToken.hasMoreTokens()) + { + meth_name = StringHelper.removeQuoteIfExists(aToken.nextToken()); + } + + DescEntry methDesc = createDescEntry(meth_name, ifc_name, parent); + + if (!ifc_name.equals(old_ifc_name)) + { + if (ifcDesc != null) + { + ifcDesc.SubEntries = getDescArray(meth_names.toArray()); + ifcDesc.SubEntryCount = meth_names.size(); + + //mark service/interface as optional if all methods/properties are optional + boolean allOptional = true; + + for (int k = 0; k < ifcDesc.SubEntryCount; k++) + { + if (!ifcDesc.SubEntries[k].isOptional) + { + allOptional = false; + } + } + + if (!ifcDesc.isOptional && allOptional) + { + ifcDesc.isOptional = allOptional; + } + + meth_names.clear(); + ifc_names.add(ifcDesc); + } + + ifcDesc = new DescEntry(); + ifcDesc.isToTest = true; + old_ifc_name = ifc_name; + + if (ifc_name.indexOf("#optional") > 0) + { + ifcDesc.isOptional = true; + ifc_name = ifc_name.substring(0, ifc_name.indexOf('#')); + } + + String className = createClassName(ifc_name); + + ifcDesc.EntryType = entryType; + ifcDesc.entryName = "ifc" + className; + ifcDesc.longName = parent.entryName + "::" + ifc_name; + } + meth_names.add(methDesc); + + } + catch (java.io.IOException ioe) + { + parent.hasErrorMsg = true; + parent.ErrorMsg = "IOException while reading the description"; + break; + } + } + + if (ifcDesc == null) { + return null; + } + + ifcDesc.SubEntries = getDescArray(meth_names.toArray()); + ifcDesc.SubEntryCount = meth_names.size(); + + //mark service/interface as optional if all methods/properties are optional + boolean allOptional = true; + + for (int k = 0; k < ifcDesc.SubEntryCount; k++) + { + if (!ifcDesc.SubEntries[k].isOptional) + { + allOptional = false; + } + } + + if (!ifcDesc.isOptional && allOptional) + { + ifcDesc.isOptional = allOptional; + } + + ifc_names.add(ifcDesc); + + return getDescArray(makeArray(ifc_names)); + } + private static String createClassName(String _ifc_name) + { + StringTokenizer st = new StringTokenizer(_ifc_name, ":"); + + int count = 3; + + if (_ifc_name.startsWith("drafts")) + { + count = 4; + } + + StringBuilder className = new StringBuilder(); + + for (int i = 0; st.hasMoreTokens(); i++) + { + String token = st.nextToken(); + + // skipping (drafts.)com.sun.star + if (i >= count) + { + if (!st.hasMoreTokens()) + { + // inserting '_' before the last token + token = "_" + token; + } + + className.append(".").append(token); + } + } + return className.toString(); + } + + private static String entryType; + + private static DescEntry createDescEntry(String meth_name, String ifc_name, DescEntry parent) + { + entryType = "service"; + DescEntry methDesc = new DescEntry(); + + if (meth_name.indexOf("#optional") > 0) + { + methDesc.isOptional = true; + meth_name = meth_name.substring(0, meth_name.indexOf('#')); + } + + if (meth_name.endsWith("()")) + { + methDesc.EntryType = "method"; + entryType = "interface"; + } + else + { + methDesc.EntryType = "property"; + entryType = "service"; + } + + methDesc.entryName = meth_name; + methDesc.isToTest = true; + + + String withoutHash = ifc_name; + + if (ifc_name.indexOf("#optional") > 0) + { + withoutHash = ifc_name.substring(0, ifc_name.indexOf('#')); + } + + methDesc.longName = parent.entryName + "::" + withoutHash + "::" + meth_name; + + return methDesc; + } + + /** + * This method ensures that XComponent will be the last in the list of interfaces + */ + private static Object[] makeArray(ArrayList<DescEntry> entries) + { + Object[] entriesArray = entries.toArray(); + ArrayList<Object> returnArray = new ArrayList<Object>(); + Object addAtEnd = null; + + for (int k = 0; k < entriesArray.length; k++) + { + DescEntry entry = (DescEntry) entriesArray[k]; + + if (entry.entryName.equals("ifc.lang._XComponent")) + { + addAtEnd = entry; + } + else + { + returnArray.add(entry); + } + } + + if (addAtEnd != null) + { + returnArray.add(addAtEnd); + } + + return returnArray.toArray(); + } + + private static DescEntry setErrorDescription(DescEntry entry, + String ErrorMsg) + { + if (entry == null) + { + entry = new DescEntry(); + } + entry.hasErrorMsg = true; + entry.ErrorMsg = "Error while getting description for test '" + + fullJob + "' as an API test: " + ErrorMsg; + + return entry; + } + + private static DescEntry[] getDescArray(Object[] list) + { + DescEntry[] entries = new DescEntry[list.length]; + + for (int i = 0; i < list.length; i++) + { + entries[i] = (DescEntry) list[i]; + } + + return entries; + } + + private DescEntry getFromClassPath(String aEntry) + { + int dotindex = aEntry.indexOf('.'); + + if (dotindex == -1) + { + return null; + } + + String module = null; + String shortName = null; + + if (aEntry.indexOf(".uno") == -1) + { + module = aEntry.substring(0, aEntry.indexOf('.')); + shortName = aEntry.substring(aEntry.indexOf('.') + 1); + } + else + { + module = aEntry.substring(0, aEntry.lastIndexOf('.')); + shortName = aEntry.substring(aEntry.lastIndexOf('.') + 1); + } + + DescEntry theEntry = new DescEntry(); + theEntry.entryName = aEntry; + theEntry.longName = aEntry; + theEntry.isOptional = false; + theEntry.EntryType = "component"; + theEntry.isToTest = true; + + BufferedReader csvFile = null; + + java.net.URL url = this.getClass().getResource("/objdsc/" + module); + + if (url == null) + { + return setErrorDescription(theEntry, + "couldn't find module '" + module + "'"); + } + + try + { + java.net.URLConnection con = url.openConnection(); + + String sEndsWithCSVName = "." + shortName.trim() + ".csv"; + if (con instanceof java.net.JarURLConnection) + { + // get Jar file from connection + java.util.jar.JarFile f = ((java.net.JarURLConnection) con).getJarFile(); + + // Enumerate over all entries + java.util.Enumeration<JarEntry> e = f.entries(); + + String sStartModule = "/" + module + "/"; + while (e.hasMoreElements()) + { + + String entry = e.nextElement().toString(); + + if ((entry.lastIndexOf(sStartModule) != -1) && + entry.endsWith(sEndsWithCSVName)) + { + InputStream input = this.getClass().getResourceAsStream("/" + entry); + csvFile = new BufferedReader(new InputStreamReader(input, "UTF-8")); + break; + } + } + } + else + { + InputStream in = con.getInputStream(); + java.io.BufferedReader buf = new java.io.BufferedReader(new InputStreamReader(in, "UTF-8")); + while (true) + { + String entry = buf.readLine(); + if (entry == null) + break; + if (entry.endsWith(sEndsWithCSVName)) + { + System.out.println("FOUND ####"); + InputStream input = + this.getClass().getResourceAsStream("/objdsc/" + + module + + "/" + + entry); + csvFile = new BufferedReader(new InputStreamReader(input, "UTF-8")); + break; + } + } + + buf.close(); + } + } + catch (java.io.IOException e) + { + e.printStackTrace(); + } + + if (csvFile == null) + { + return setErrorDescription(theEntry, + "couldn't find component '" + + theEntry.entryName + "'"); + } + + DescEntry[] subEntries = getSubEntries(csvFile, theEntry); + + theEntry.SubEntryCount = subEntries != null ? subEntries.length : 0; + theEntry.SubEntries = subEntries; + + try + { + csvFile.close(); + } + catch (java.io.IOException ioe) + { + System.out.println("Exception while closing csvFile"); + } + + return theEntry; + } + + private static DescEntry getFromDirectory(String descPath, String entry, + boolean debug) + { + int dotindex = entry.indexOf('.'); + + if (dotindex == -1) + { + return null; + } + + String fs = System.getProperty("file.separator"); + String module = null; + String shortName = null; + + if (entry.indexOf(".uno") == -1) + { + module = entry.substring(0, entry.indexOf('.')); + shortName = entry.substring(entry.indexOf('.') + 1); + } + else + { + module = entry.substring(0, entry.lastIndexOf('.')); + shortName = entry.substring(entry.lastIndexOf('.') + 1); + } + + DescEntry aEntry = new DescEntry(); + aEntry.entryName = entry; + aEntry.longName = entry; + aEntry.isOptional = false; + aEntry.EntryType = "component"; + aEntry.isToTest = true; + + if (debug) + { + System.out.println("Parsing Description Path: " + descPath); + System.out.println("Searching module: " + module); + System.out.println("For the Component " + shortName); + } + + File modPath = new File(descPath + fs + module); + + if (!modPath.exists()) + { + return setErrorDescription(aEntry, + "couldn't find module '" + module + "'"); + } + + String[] files = modPath.list(); + String found = "none"; + + for (int i = 0; i < files.length; i++) + { + if (files[i].endsWith("." + shortName + ".csv")) + { + found = files[i]; + System.out.println("found " + found); + break; + } + } + + if (found.equals("none")) + { + return setErrorDescription(aEntry, + "couldn't find component '" + entry + "'"); + } + + String aUrl = descPath + fs + module + fs + found; + + BufferedReader csvFile = null; + + try + { + csvFile = new BufferedReader(new FileReader(aUrl)); + } + catch (java.io.FileNotFoundException fnfe) + { + return setErrorDescription(aEntry, "couldn't find file '" + aUrl + "'"); + } + + DescEntry[] subEntries = getSubEntries(csvFile, aEntry); + + try + { + csvFile.close(); + } + catch (java.io.IOException ioe) + { + System.out.println("Exception while closing csvFile"); + } + + aEntry.SubEntryCount = subEntries != null ? subEntries.length : 0; + aEntry.SubEntries = subEntries; + + return aEntry; + } + + @Override + protected ArrayList<String> getSubInterfaces(String job) + { + ArrayList<String> namesList = new ArrayList<String>(); + StringTokenizer st = new StringTokenizer(job, ","); + + while (st.hasMoreTokens()) + { + String token = st.nextToken(); + + if (token.indexOf('.') < 0) + { + namesList.add(token); + } + } + + return namesList; + } + + private ArrayList<String> getSubObjects(String job) + { + ArrayList<String> namesList = new ArrayList<String>(); + StringTokenizer st = new StringTokenizer(job, ","); + + while (st.hasMoreTokens()) + { + namesList.add(st.nextToken()); + } + + return namesList; + } + + @Override + protected String[] createScenario(String descPath, String job, + boolean debug) + { + String[] scenario = null; + + if (descPath != null) + { + if (debug) + { + System.out.println("## reading from File " + descPath); + } + + scenario = getScenarioFromDirectory(descPath, job); + } + else + { + if (debug) + { + System.out.println("## reading from jar"); + } + + scenario = getScenarioFromClassPath(job); + } + + return scenario; + } + + private String[] getScenarioFromDirectory(String descPath, String job) + { + String[] modules = null; + ArrayList<String> componentList = new ArrayList<String>(); + + if (!job.equals("unknown") && !job.equals("listall")) + { + modules = new String[] + { + job + }; + } + else + { + File dirs = new File(descPath); + + if (dirs.exists()) { + modules = dirs.list(); + } + } + + int moduleLength = modules != null ? modules.length : 0; + + for (int i = 0; i < moduleLength; ++i) + { + if (!isUnusedModule(modules[i])) + { + File moduleDir = new File(descPath + System.getProperty("file.separator") + modules[i]); + if (moduleDir.exists()) + { + String[] components = moduleDir.list(); + for (int j = 0; j < components.length; j++) + { + if (components[j].endsWith(".csv")) + { + String toAdd = getComponentForString(components[j], modules[i]); + toAdd = "-o " + modules[i] + "." + toAdd; + componentList.add(toAdd); + } + } + } + } + } + + Collections.sort(componentList); + String[] scenario = componentList.toArray(new String[componentList.size()]); + return scenario; + } + + private String[] getScenarioFromClassPath(String job) + { + String subdir = "/"; + + if (!job.equals("unknown") && !job.equals("listall")) + { + subdir += job; + } + + java.net.URL url = this.getClass().getResource("/objdsc" + subdir); + + if (url == null) + { + return null; + } + + ArrayList<String> scenarioList = new ArrayList<String>(); + + try + { + java.net.URLConnection con = url.openConnection(); + + if (con instanceof java.net.JarURLConnection) + { + // get Jar file from connection + java.util.jar.JarFile f = ((java.net.JarURLConnection) con).getJarFile(); + + // Enumerate over all entries + java.util.Enumeration<JarEntry> e = f.entries(); + + while (e.hasMoreElements()) + { + String entry = e.nextElement().toString(); + + if (entry.startsWith("objdsc" + subdir) && + (entry.indexOf("CVS") < 0) && + !entry.endsWith("/")) + { + int startMod = entry.indexOf('/'); + int endMod = entry.lastIndexOf('/'); + String module = entry.substring(startMod + 1, endMod); + String component = getComponentForString( + entry.substring(endMod + 1, + entry.length()), + module); + + if (!isUnusedModule(module)) + { + scenarioList.add("-o " + module + "." + + component); + } + } + } + } + } + catch (java.io.IOException e) + { + e.printStackTrace(); + } + + Collections.sort(scenarioList); + String[] scenario = scenarioList.toArray(new String[scenarioList.size()]); + return scenario; + } + + private String getComponentForString(String full, String module) + { + String component = ""; + + + //cutting .csv + full = full.substring(0, full.length() - 4); + + //cutting component + int lastdot = full.lastIndexOf('.'); + component = full.substring(lastdot + 1, full.length()); + + if (module.equals("file") || module.equals("xmloff")) + { + String withoutComponent = full.substring(0, lastdot); + int preLastDot = withoutComponent.lastIndexOf('.'); + component = withoutComponent.substring(preLastDot + 1, + withoutComponent.length()) + + "." + component; + } + + return component; + } + + private boolean isUnusedModule(String moduleName) + { + ArrayList<String> removed = new ArrayList<String>(); + removed.add("acceptor"); + removed.add("brdgfctr"); + removed.add("connector"); + removed.add("corefl"); + removed.add("cpld"); + removed.add("defreg"); + removed.add("dynamicloader"); + removed.add("impreg"); + removed.add("insp"); + removed.add("inv"); + removed.add("invadp"); + removed.add("javaloader"); + removed.add("jen"); + removed.add("namingservice"); + removed.add("proxyfac"); + removed.add("rdbtdp"); + removed.add("remotebridge"); + removed.add("simreg"); + removed.add("smgr"); + removed.add("stm"); + removed.add("tcv"); + removed.add("tdmgr"); + removed.add("ucprmt"); + removed.add("uuresolver"); + + return removed.contains(moduleName); + } +} |