| /************************************************************** |
| * |
| * 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 org.openoffice; |
| |
| import share.LogWriter; |
| import stats.InternalLogWriter; |
| import lib.TestParameters; |
| import util.DynamicClassLoader; |
| import base.TestBase; |
| import helper.ClParser; |
| import helper.CfgParser; |
| import com.sun.star.beans.XPropertyAccess; |
| import com.sun.star.beans.PropertyValue; |
| import com.sun.star.task.XJob; |
| import com.sun.star.uno.XInterface; |
| import com.sun.star.comp.loader.FactoryHelper; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.lang.XServiceInfo; |
| import com.sun.star.lang.XSingleServiceFactory; |
| import com.sun.star.lang.XTypeProvider; |
| import com.sun.star.uno.Type; |
| import com.sun.star.registry.XRegistryKey; |
| import com.sun.star.beans.NamedValue; |
| |
| import java.util.Vector; |
| |
| /** |
| * The main class, will call ClParser and CfgParser to <br> |
| * fill the TestParameters.<br> |
| * Will then call the appropriate Testbase to run the tests. |
| */ |
| public class RunnerService implements XJob, XServiceInfo, |
| XTypeProvider, XPropertyAccess { |
| |
| static public final String __serviceName = "org.openoffice.Runner"; |
| static public final String __implName = "org.openoffice.RunnerService"; |
| static private XMultiServiceFactory xMSF = null; |
| |
| /** |
| * ct'tor |
| * Construct an own office provider for tests |
| */ |
| public RunnerService(XMultiServiceFactory xMSF) { |
| } |
| |
| public Object execute(NamedValue[] args) { |
| // construct valid arguments from the given stuff |
| int arg_length=args.length; |
| String[] arguments = new String[arg_length*2]; |
| for ( int i=0; i< arg_length; i++ ) { |
| arguments[i*2] = args[i].Name; |
| Object o = args[i].Value; |
| arguments[i*2+1] = o.toString(); |
| } |
| |
| TestParameters param = new TestParameters(); |
| DynamicClassLoader dcl = new DynamicClassLoader(); |
| |
| |
| // take the standard log writer |
| String standardLogWriter = param.LogWriter; |
| String standardOutProducer = param.OutProducer; |
| |
| ClParser cli = new ClParser(); |
| |
| //parse the arguments if an ini-parameter is given |
| String iniFile = cli.getIniPath(arguments); |
| |
| //initialize cfgParser with ini-path |
| CfgParser ini = new CfgParser(iniFile); |
| |
| //parse ConfigFile |
| ini.getIniParameters(param); |
| |
| |
| //parse the commandline arguments if an runnerprops-parameter is given |
| String runnerIniFile = cli.getRunnerIniPath(arguments); |
| |
| //initialize cfgParser with ini-path |
| CfgParser runnerIni = new CfgParser(runnerIniFile); |
| |
| //parse ConfigFile |
| runnerIni.getIniParameters(param); |
| |
| //parse the commandline arguments |
| cli.getCommandLineParameter(param,arguments); |
| |
| // now compare the standard log writer with the parameters: |
| // if we have a new one, use the new, else use the internal |
| // log writer |
| if (((String)param.get("LogWriter")).equals(standardLogWriter)) |
| param.put("LogWriter", "stats.InternalLogWriter"); |
| if (((String)param.get("OutProducer")).equals(standardOutProducer)) |
| param.put("OutProducer", "stats.InternalLogWriter"); |
| LogWriter log = (LogWriter) dcl.getInstance( |
| (String)param.get("LogWriter")); |
| |
| param.put("ServiceFactory", xMSF); |
| |
| param.ServiceFactory = xMSF; //(XMultiServiceFactory) |
| // appProvider.getManager(param); |
| |
| log.println("TestJob: "+param.get("TestJob")); |
| |
| TestBase toExecute = (TestBase)dcl.getInstance("base.java_fat_service"); |
| |
| boolean worked = toExecute.executeTest(param); |
| if (!worked) |
| log.println("Test did not execute correctly."); |
| |
| String returnString = ""; |
| if (log instanceof InternalLogWriter) |
| returnString = ((InternalLogWriter)log).getLog(); |
| return returnString; |
| } |
| |
| /** |
| * This function provides the service name |
| * @return the service name |
| */ |
| public String getServiceName() { |
| return __serviceName; |
| } |
| |
| /** |
| * Get all implemented types of this class. |
| * @return An array of implemented interface types. |
| * @see com.sun.star.lang.XTypeProvider |
| */ |
| public Type[] getTypes() { |
| Type[] type = new Type[5]; |
| type[0] = new Type(XInterface.class); |
| type[1] = new Type(XTypeProvider.class); |
| type[2] = new Type(XJob.class); |
| type[3] = new Type(XServiceInfo.class); |
| type[4] = new Type(XPropertyAccess.class); |
| return type; |
| } |
| |
| /** |
| * Get the implementation id. |
| * @return An empty implementation id. |
| * @see com.sun.star.lang.XTypeProvider |
| */ |
| public byte[] getImplementationId() { |
| return new byte[0]; |
| } |
| /** |
| * Function for reading the implementation name. |
| * |
| * @return the implementation name |
| * @see com.sun.star.lang.XServiceInfo |
| */ |
| public String getImplementationName() { |
| return __implName; |
| } |
| |
| /** |
| * Does the implementation support this service? |
| * |
| * @param serviceName The name of the service in question |
| * @return true, if service is supported, false otherwise |
| * @see com.sun.star.lang.XServiceInfo |
| */ |
| public boolean supportsService(String serviceName) { |
| if(serviceName.equals(__serviceName)) |
| return true; |
| return false; |
| } |
| |
| /** |
| * Function for reading all supported services |
| * |
| * @return An aaray with all supported service names |
| * @see com.sun.star.lang.XServiceInfo |
| */ |
| public String[] getSupportedServiceNames() { |
| String[] supServiceNames = {__serviceName}; |
| return supServiceNames; |
| } |
| |
| /** |
| * Return all valid testcases from the object descriptions |
| * @return The valid testcases as property values |
| */ |
| public PropertyValue[] getPropertyValues() { |
| PropertyValue[] pVal = null; |
| java.net.URL url = this.getClass().getResource("/objdsc"); |
| if (url == null) { |
| pVal = new PropertyValue[1]; |
| pVal[0] = new PropertyValue(); |
| pVal[0].Name = "Error"; |
| pVal[0].Value = "OOoRunner.jar file doesn't contain object " + |
| "descriptions: don't know what to test."; |
| return pVal; |
| } |
| |
| Vector v = new Vector(600); |
| try { |
| // open connection to Jar |
| java.net.JarURLConnection con = |
| (java.net.JarURLConnection)url.openConnection(); |
| // get Jar file from connection |
| java.util.jar.JarFile f = con.getJarFile(); |
| // Enumerate over all entries |
| java.util.Enumeration aEnum = f.entries(); |
| |
| while (aEnum.hasMoreElements()) { |
| String entry = aEnum.nextElement().toString(); |
| if (entry.endsWith(".csv")) { |
| |
| String module = null; |
| String object = null; |
| |
| int startIndex = entry.indexOf("objdsc/") + 7; |
| int endIndex = entry.lastIndexOf('/'); |
| /* int endIndex = entry.indexOf('.'); |
| module = entry.substring(startIndex, endIndex); |
| startIndex = 0; |
| endIndex = module.lastIndexOf('/'); */ |
| module = entry.substring(startIndex, endIndex); |
| |
| // special cases |
| if (entry.indexOf("/file/") != -1 || entry.indexOf("/xmloff/") != -1) { |
| endIndex = entry.indexOf(".csv"); |
| object = entry.substring(0, endIndex); |
| endIndex = object.lastIndexOf('.'); |
| startIndex = object.indexOf('.'); |
| while (startIndex != endIndex) { |
| object = object.substring(startIndex+1); |
| startIndex = object.indexOf('.'); |
| endIndex = object.lastIndexOf('.'); |
| } |
| } |
| /* else if (entry.indexOf("/xmloff/") != -1) { |
| endIndex = entry.indexOf(".csv"); |
| object = entry.substring(0, endIndex); |
| endIndex = entry.lastIndexOf('.'); |
| while (object.indexOf('.') != endIndex) { |
| object = object.substring(object.indexOf('.')+1); |
| } |
| } */ |
| else { |
| startIndex = 0; |
| endIndex = entry.indexOf(".csv"); |
| object = entry.substring(startIndex, endIndex); |
| startIndex = object.lastIndexOf('.'); |
| object = object.substring(startIndex+1); |
| } |
| v.add(module+"."+object); |
| } |
| } |
| } |
| catch(java.io.IOException e) { |
| e.printStackTrace(); |
| } |
| |
| int size = v.size(); |
| |
| String[] sTestCases = new String[size]; |
| v.toArray(sTestCases); |
| java.util.Arrays.sort(sTestCases); |
| |
| pVal = new PropertyValue[size]; |
| for (int i=0; i<size; i++) { |
| pVal[i] = new PropertyValue(); |
| pVal[i].Name = "TestCase"+i; |
| pVal[i].Value = sTestCases[i]; |
| } |
| return pVal; |
| } |
| |
| |
| /** |
| * |
| * Gives a factory for creating the service. |
| * This method is called by the <code>JavaLoader</code> |
| * <p> |
| * @return returns a <code>XSingleServiceFactory</code> for creating the component |
| * @param implName the name of the implementation for which a service is desired |
| * @param multiFactory the service manager to be used if needed |
| * @param regKey the registryKey |
| * @see com.sun.star.comp.loader.JavaLoader |
| */ |
| public static XSingleServiceFactory __getServiceFactory(String implName, |
| XMultiServiceFactory multiFactory, XRegistryKey regKey) |
| { |
| XSingleServiceFactory xSingleServiceFactory = null; |
| |
| if (implName.equals(RunnerService.class.getName())) |
| xSingleServiceFactory = FactoryHelper.getServiceFactory( |
| RunnerService.class, __serviceName, multiFactory, regKey); |
| xMSF = multiFactory; |
| return xSingleServiceFactory; |
| } |
| |
| /** |
| * Writes the service information into the given registry key. |
| * This method is called by the <code>JavaLoader</code> |
| * <p> |
| * @return returns true if the operation succeeded |
| * @param regKey the registryKey |
| * @see com.sun.star.comp.loader.JavaLoader |
| */ |
| public static boolean __writeRegistryServiceInfo(XRegistryKey regKey) { |
| return FactoryHelper.writeRegistryServiceInfo(RunnerService.class.getName(), |
| __serviceName, regKey); |
| } |
| |
| /** |
| * empty: not needed here. |
| */ |
| public void setPropertyValues(PropertyValue[] propertyValue) |
| throws com.sun.star.beans.UnknownPropertyException, |
| com.sun.star.beans.PropertyVetoException, |
| com.sun.star.lang.IllegalArgumentException, |
| com.sun.star.lang.WrappedTargetException { |
| // empty implementation |
| } |
| |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
