/**************************************************************
*
* 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 lib;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Vector;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XInterface;
import share.DescEntry;
import lib.TestParameters;
import stats.Summarizer;
/**
* The class supports method based interface tests development.
*
* <p>There are some points that should be fulfilled in a subclass to work
* correctly in the multi-method framework:
*
* 1. each subclass schould define a public field named oObj of type tested
* by the subclass, e.g. 'public XText oObj;'. That field will be initialized
* by the MultiMethodTest code with the instance of the interface to test.
* In a case of service testing the field type should be XPropertySet.
*
* 2. for the test of each method of the tested interface(or a property in the
* case of service testing) should be method with the following signature
* provided: 'public void _<method name>()', e.g. 'public void _getText()'.
* The methods will be called by MultiMethodText code using reflection API
* for each method in the interface description.
*
* 3. to set status for a call 'tRes.tested(String method,
* boolean result)' should be used. For example 'tRes.tested("getText()",
* true)'. Also 'tRes.assert(String assertion, boolean result)' call can
* be used. Note, that one can call the methods not neccesarily from the
* test for the tested method, but from other method tests too (in the
* MultiMethodTest subclass). See also TestResult and MultiMethodTest.tRes
* documentation.
*
* 4. the before() and after() methods can be overriden to perform some
* actions, accordingly, before and after calling the test methods.
*
* 5. besides tRes, there are some fields initialized in the MultiMethodTest,
* that can be used for implementing tests:
*
* - tEnv contains the environment tested
* - tParam contains parameters of the test
* - log a writer to log information about the test
*
* @see TestResult
*/
public class MultiMethodTest
{
/**
* Contains the TestEnvironment being tested, to allow for tests to access
* it.
*/
protected TestEnvironment tEnv;
/**
* Contains the TestParameters for the tests, to allow for tests to access
* it.
*/
protected TestParameters tParam;
/**
* Contains the Description for the test
* it.
*/
protected DescEntry entry;
/**
* Contains a writer to log an information about the interface testing, to
* allows for tests to access it.
*/
protected PrintWriter log;
/**
* Contains the TestResult instance for the interface test to collect
* information about methods test.
*/
protected TestResult tRes;
/**
* Contains names of the methods have been alreadycalled
*/
private Vector methCalled = new Vector(10);
/**
* Disposes the test environment, which was corrupted by the test.
*
* @param tEnv the environment to dispose
*/
public void disposeEnvironment(TestEnvironment tEnv)
{
disposeEnvironment();
}
/**
* Disposes the current test environment, which was corrupted by the test.
*
* @see #disposeEnvironment(TestEnvironment)
*/
public void disposeEnvironment()
{
tEnv.dispose();
TestCase tCase = tEnv.getTestCase();
tCase.disposeTestEnvironment(tEnv, tParam);
}
/**
* Runs the interface test: its method tests. First, it initializes some
* of MultiMethodTest fields, like tRes, log, tEnv, etc. Then, it queries
* the tested interface and initializes 'oObj' field (defined in a
* subclass). Before calling method tests, before() method calles to allow
* initialization of s stuff before testing. Then, the method tests are
* called. After them, after() method is called, to allow cleaning up the
* stuff initialized in before() and test methods.
*
* @param entry the interface test state
* @param tEnv the environment to test
* @param tParam the parameters of the test
*
* @see #before
* @see #after
*/
public TestResult run(DescEntry entry, TestEnvironment tEnv, TestParameters tParam)
{
log = (PrintWriter) entry.Logger;
this.tEnv = tEnv;
this.tParam = tParam;
// this.log = log;
this.entry = entry;
this.tRes = new TestResult();
Class testedClass;
// Some fake code for a self test.
// For normal test we must not be a "ifc.qadevooo._SelfTest"
if (! entry.entryName.equals("ifc.qadevooo._SelfTest"))
{
String ifcName = getInterfaceName();
// System.out.println("checking : " + ifcName);
System.out.print("checking: [" + entry.longName + "]");
// defining a name of the class corresponding to the tested interface
// or service
String testedClassName;
testedClassName = getTestedClassName();
if (entry.EntryType.equals("service"))
{
testedClassName = "com.sun.star.beans.XPropertySet";
}
try
{
testedClass = Class.forName(testedClassName);
}
catch (ClassNotFoundException cnfE)
{
System.out.println();
cnfE.printStackTrace(log);
log.println("could not find a class : " + getTestedClassName());
return null;
}
System.out.println(" is iface: [" + testedClassName + "] testcode: [" + entry.entryName + "]");
// quering the tested interface from the tested object
XInterface tCase = tEnv.getTestObject();
Object oObj = UnoRuntime.queryInterface(testedClass, tEnv.getTestObject());
if (oObj == null)
{
if (entry.isOptional)
{
Summarizer.summarizeDown(entry, "Not supported but optional.OK");
}
else
{
Summarizer.summarizeDown(entry, "queryInterface returned null.FAILED");
entry.ErrorMsg = "queryInterface returned null";
entry.hasErrorMsg = true;
}
return null;
}
//setting the field oObj
setField("oObj", oObj);
}
// to perform some stuff before all method tests
try
{
before();
}
catch (Exception e)
{
setSubStates(e.toString());
return tRes;
}
// executing methods tests
for (int i = 0; i < entry.SubEntryCount; i++)
{
DescEntry aSubEntry = entry.SubEntries[i];
try
{
final String sEntryName = aSubEntry.entryName;
executeMethod(sEntryName);
}
catch (Exception e)
{
log.println("Exception while checking: " + aSubEntry.entryName + " : " + e.getMessage());
}
}
// to perform some stuff after all method tests
try
{
after();
}
catch (Exception e)
{
}
return tRes;
}
/**
* Is called before calling method tests, but after initialization.
* Subclasses may override to perform actions before method tests.
*/
protected void before()
{
}
/**
* Is called after calling method tests. Subclasses may override
* to perform actions after method tests.
*/
protected void after()
{
}
/**
* @return the name of the interface or the service tested.
*/
protected String getTestedClassName()
{
String clsName = this.getClass().getName();
int firstDot = clsName.indexOf(".");
int lastDot = clsName.lastIndexOf(".");
String append = "com.sun.star.";
if (entry.longName.indexOf("::drafts::com::") > -1)
{
append = "drafts.com.sun.star.";
}
return append + clsName.substring(firstDot + 1, lastDot + 1) + clsName.substring(lastDot + 2);
}
/**
* Sets a method status.
*
* @param methName the method name to set status
* @param methStatus the status to set to the method
*/
protected void setStatus(String methName, Status methStatus)
{
tRes.tested(methName, methStatus);
}
/**
* sets the substates
*/
protected void setSubStates(String msg)
{
for (int k = 0; k < entry.SubEntryCount; k++)
{
entry.SubEntries[k].hasErrorMsg = true;
entry.SubEntries[k].ErrorMsg = msg;
if (entry.SubEntries[k].State.equals("UNKNOWN"))
{
entry.SubEntries[k].State = msg;
}
}
}
/**
* Checks if the <code>method</code> is optional in the service.
*/
protected boolean isOptional(String _method)
{
for (int k = 0; k < entry.SubEntryCount; k++)
{
final String sName = entry.SubEntries[k].entryName;
if (sName.equals(_method))
{
final boolean bIsOptional = entry.SubEntries[k].isOptional;
return bIsOptional;
}
}
return false;
}
/**
* Checks if the <code>method</code> test has been already called.
*/
protected boolean isCalled(String method)
{
return methCalled.contains(method);
}
/**
* Calling of the method indicates that the <code>method</code> test should
* be called. The method checks this and if it is not called, calls it.
* If the method is failed or skipped, it throws StatusException.
*/
protected void requiredMethod(String method)
{
log.println("starting required method: " + method);
executeMethod(method);
Status mtStatus = tRes.getStatusFor(method);
if (mtStatus != null && (!mtStatus.isPassed() || mtStatus.isFailed()))
{
log.println("! Required method " + method + " failed");
throw new StatusException(mtStatus);
}
}
/**
* Checks if the <code>method</code> was called, and if not, call it.
* On contrary to requiredMethod(), he method doesn't check its status.
*/
protected void executeMethod(String method)
{
if (!isCalled(method))
{
log.println("Execute: " + method);
callMethod(method);
log.println(method + ": " + tRes.getStatusFor(method));
log.println();
}
}
/**
* Just calls the <code>method</code> test.
*/
protected void callMethod(String method)
{
methCalled.add(method);
invokeTestMethod(getMethodFor(method), method);
}
/**
* Invokes a test method of the subclass using reflection API. Handles
* the method results and sets its status.
*
* @param meth the subclass' method to invoke
* @param methName the name of the method
*/
protected void invokeTestMethod(Method meth, String methName)
{
if (meth == null)
{
setStatus(methName, Status.skipped(false));
}
else
{
Status stat;
try
{
meth.invoke(this, new Object[0]);
return;
}
catch (InvocationTargetException itE)
{
Throwable t = itE.getTargetException();
if (t instanceof StatusException)
{
stat = ((StatusException) t).getStatus();
}
else
{
t.printStackTrace(log);
stat = Status.exception(t);
}
}
catch (IllegalAccessException iaE)
{
iaE.printStackTrace(log);
stat = Status.exception(iaE);
}
catch (IllegalArgumentException iaE)
{
iaE.printStackTrace(log);
stat = Status.exception(iaE);
}
catch (ClassCastException ccE)
{
ccE.printStackTrace(log);
stat = Status.exception(ccE);
}
setStatus(methName, stat);
}
}
/**
* Finds a testing method for the <code>method</code> of the interface.
*
* @return the testing method, if found, <tt>null</tt> otherwise
*/
protected Method getMethodFor(String method)
{
String mName = "_" + method;
if (mName.endsWith("()"))
{
mName = mName.substring(0, mName.length() - 2);
}
final Class[] paramTypes = new Class[0];
try
{
return this.getClass().getDeclaredMethod(mName, paramTypes);
}
catch (NoSuchMethodException nsmE)
{
return null;
}
}
/**
* @return the name of the interface tested
*/
public String getInterfaceName()
{
String clName = this.getClass().getName();
return clName.substring(clName.lastIndexOf('.') + 1);
}
/**
* Initializes <code>fieldName</code> of the subclass with
* <code>value</code>.
*
* @return Status describing the result of the operation.
*/
protected Status setField(String fieldName, Object value)
{
Field objField;
try
{
objField = this.getClass().getField(fieldName);
}
catch (NoSuchFieldException nsfE)
{
return Status.exception(nsfE);
}
try
{
objField.set(this, value);
return Status.passed(true);
}
catch (IllegalArgumentException iaE)
{
return Status.exception(iaE);
}
catch (IllegalAccessException iaE)
{
return Status.exception(iaE);
}
}
}