Cactus 1.5 for J2EE API 1.2

Clover coverage report - Cactus 1.5 for J2EE API 1.2

Coverage timestamp: Wed Feb 18 2004 09:04:33 EST

FRAMES NO FRAMES

file stats:	LOC:	442		Methods:	21
	NCLOC:	189		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

ClientTestCaseDelegate.java

 /*
  * ====================================================================
  *
  * The Apache Software License, Version 1.1
  *
  * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution, if
  *    any, must include the following acknowlegement:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowlegement may appear in the software itself,
  *    if and wherever such third-party acknowlegements normally appear.
  *
  * 4. The names "The Jakarta Project", "Cactus" and "Apache Software
  *    Foundation" must not be used to endorse or promote products
  *    derived from this software without prior written permission. For
  *    written permission, please contact apache@apache.org.
  *
  * 5. Products derived from this software may not be called "Apache"
  *    nor may "Apache" appear in their names without prior written
  *    permission of the Apache Group.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  *
  */
 package org.apache.cactus.internal.client;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 
 import junit.framework.Assert;
 import junit.framework.Test;
 
 import org.apache.cactus.Request;
 import org.apache.cactus.WebRequest;
 import org.apache.cactus.configuration.Configuration;
 import org.apache.cactus.util.JUnitVersionHelper;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 /**
  * Delegate class that provides useful methods for the Cactus  
  * <code>XXXTestCase</code> classes. All the methods provided are independent
  * of any communication protocol between client side and server side (HTTP, 
  * JMS, etc). Subclasses will define additional behaviour that depends on the 
  * protocol.
  *  
  * It provides the ability to run common code before each test on the client 
  * side (note that calling common tear down code is delegated to child classes 
  * as the method signature depends on the protocol used).
  *
  * In addition it provides the ability to execute some one time (per-JVM)
  * initialisation code (a pity this is not provided in JUnit). It can be 
  * useful to start an embedded server for example. Note: In the future this
  * should be refatored and provided using a custom JUnit TestSuite.
  *
  * @author <a href="mailto:vmassol@apache.org">Vincent Massol</a>
  *
  * @version $Id: ClientTestCaseDelegate.java,v 1.2.2.1 2003/08/31 14:38:18 vmassol Exp $
  */
 public class ClientTestCaseDelegate extends Assert
 {
     /**
      * The prefix of a test method.
      */
     protected static final String TEST_METHOD_PREFIX = "test";
 
     /**
      * The prefix of a begin test method.
      */
     protected static final String BEGIN_METHOD_PREFIX = "begin";
 
     /**
      * The prefix of an end test method.
      */
     protected static final String END_METHOD_PREFIX = "end";
 
     /**
      * The name of the method that is called before each test on the client
      * side (if it exists).
      */
     protected static final String CLIENT_GLOBAL_BEGIN_METHOD = "begin";
 
     /**
      * The name of the method that is called after each test on the client
      * side (if it exists).
      */
     protected static final String CLIENT_GLOBAL_END_METHOD = "end";
 
     /**
      * The logger (only used on the client side).
      */
     private Log logger;
 
     /**
      * The Cactus configuration.
      */
     private Configuration configuration;
 
     /**
      * Pure JUnit Test Case that we are wrapping (if any)
      */
     private Test wrappedTest;
 
     /**
      * The test we are delegating for.
      */
     private Test delegatedTest;   
     
     /**
      * @param theDelegatedTest the test we are delegating for
      * @param theWrappedTest the test being wrapped by this delegate (or null 
      *        if none)
      * @param theConfiguration the configuration to use 
      */
     public ClientTestCaseDelegate(Test theDelegatedTest, 
         Test theWrappedTest, Configuration theConfiguration)
     {        
         if (theDelegatedTest == null)
         {
             throw new IllegalStateException(
                 "The test object passed must not be null");
         }
 
         setDelegatedTest(theDelegatedTest); 
         setWrappedTest(theWrappedTest);
         setConfiguration(theConfiguration);               
     }
 
     /**
      * @param theWrappedTest the pure JUnit test that we need to wrap 
      */
     public void setWrappedTest(Test theWrappedTest)
     {
         this.wrappedTest = theWrappedTest;
     }
 
     /**
      * @param theDelegatedTest the test we are delegating for
      */
     public void setDelegatedTest(Test theDelegatedTest)
     {
         this.delegatedTest = theDelegatedTest;
     }
 
     /**
      * @return the wrapped JUnit test
      */
     public Test getWrappedTest()
     {
         return this.wrappedTest;
     }
 
     /**
      * @return the test we are delegating for
      */
     public Test getDelegatedTest()
     {
         return this.delegatedTest;
     }
 
     /**
      * @return the test on which we will operate. If there is a wrapped
      *         test then the returned test is the wrapped test. Otherwise we
      *         return the delegated test.
      */
     public Test getTest()
     {
         Test activeTest;
         if (getWrappedTest() != null)
         {
             activeTest = getWrappedTest();
         }
         else
         {
             activeTest = getDelegatedTest();
         }
         return activeTest;
     }
 
     
     /**
      * @return The logger used by the <code>TestCase</code> class and
      *         subclasses to perform logging.
      */
     public final Log getLogger()
     {
         return this.logger;
     }
 
     /**
      * @param theLogger the logger to use 
      */
     protected void setLogger(Log theLogger)
     {
         this.logger = theLogger;
     }
     
     /**
      * @return the Cactus configuration
      */
     public Configuration getConfiguration()
     {
         return this.configuration;
     }
 
     /**
      * Sets the Cactus configuration
      * 
      * @param theConfiguration the Cactus configuration
      */
     public void setConfiguration(Configuration theConfiguration)
     {
         this.configuration = theConfiguration;
     }
    
     /**
      * @return the name of the test method to call without the
      *         TEST_METHOD_PREFIX prefix
      */
     private String getBaseMethodName()
     {
         // Sanity check
         if (!getCurrentTestName().startsWith(TEST_METHOD_PREFIX))
         {
             throw new RuntimeException("bad name ["
                 + getCurrentTestName()
                 + "]. It should start with ["
                 + TEST_METHOD_PREFIX + "].");
         }
 
         return getCurrentTestName().substring(
             TEST_METHOD_PREFIX.length());
     }
 
     /**
      * @return the name of the test begin method to call that initialize the
      *         test by initializing the <code>WebRequest</code> object
      *         for the test case.
      */
     protected String getBeginMethodName()
     {
         return BEGIN_METHOD_PREFIX + getBaseMethodName();
     }
 
     /**
      * @return the name of the test end method to call when the test has been
      *         run on the server. It can be used to verify returned headers,
      *         cookies, ...
      */
     protected String getEndMethodName()
     {
         return END_METHOD_PREFIX + getBaseMethodName();
     }
 
     /**
      * Perform client side initializations before each test, such as
      * re-initializating the logger and printing some logging information.
      */
     public void runBareInit()
     {
         // We make sure we reinitialize The logger with the name of the
         // current extending class so that log statements will contain the
         // actual class name (that's why the logged instance is not static).
         this.logger = LogFactory.getLog(this.getClass());
 
         // Mark beginning of test on client side
         getLogger().debug("------------- Test: " 
             + this.getCurrentTestName());        
     }
 
     /**
      * Call a begin method which takes Cactus WebRequest as parameter
      *
      * @param theRequest the request object which will contain data that will
      *        be used to connect to the Cactus server side redirectors.
      * @param theMethodName the name of the begin method to call
      * @exception Throwable any error that occurred when calling the method
      */
     private void callGenericBeginMethod(Request theRequest, 
         String theMethodName) throws Throwable
     {
         // First, verify if a begin method exist. If one is found, verify if
         // it has the correct signature. If not, send a warning.
         Method[] methods = getTest().getClass().getMethods();
 
         for (int i = 0; i < methods.length; i++)
         {
             if (methods[i].getName().equals(theMethodName))
             {
                 // Check return type
                 if (!methods[i].getReturnType().getName().equals("void"))
                 {
                     fail("The method [" + methods[i].getName()
                         + "] should return void and not ["
                         + methods[i].getReturnType().getName() + "]");
                 }
 
                 // Check if method is public
                 if (!Modifier.isPublic(methods[i].getModifiers()))
                 {
                     fail("Method [" + methods[i].getName()
                         + "] should be declared public");
                 }
 
                 // Check parameters
                 Class[] parameters = methods[i].getParameterTypes();
 
                 if (parameters.length != 1)
                 {
                     fail("The method [" + methods[i].getName()
                         + "] must accept a single parameter derived from "
                         + "class [" + WebRequest.class.getName() + "], "
                         + "but " + parameters.length
                         + " parameters were found");
                 }
                 else if (!theRequest.getClass().isAssignableFrom(parameters[0]))
                 {
                     fail("The method [" + methods[i].getName()
                         + "] must accept a single parameter derived from "
                         + "class [" + theRequest.getClass().getName() + "], "
                         + "but found a [" + parameters[0].getName() + "] "
                         + "parameter instead");
                 }
 
                 try
                 {
                     methods[i].invoke(getTest(), new Object[] {theRequest});
 
                     break;
                 }
                 catch (InvocationTargetException e)
                 {
                     e.fillInStackTrace();
                     throw e.getTargetException();
                 }
                 catch (IllegalAccessException e)
                 {
                     e.fillInStackTrace();
                     throw e;
                 }
             }
         }
     }
 
     /**
      * Call the global begin method. This is the method that is called before
      * each test if it exists. It is called on the client side only.
      *
      * @param theRequest the request object which will contain data that will
      *        be used to connect to the Cactus server side redirectors.
      * @exception Throwable any error that occurred when calling the method
      */
     protected void callClientGlobalBegin(Request theRequest) throws Throwable
     {
         callGenericBeginMethod(theRequest, CLIENT_GLOBAL_BEGIN_METHOD);
     }
 
     /**
      * Call the test case begin method.
      *
      * @param theRequest the request object to pass to the begin method.
      * @exception Throwable any error that occurred when calling the begin
      *            method for the current test case.
      */
     public void callBeginMethod(Request theRequest) throws Throwable
     {
         callGenericBeginMethod(theRequest, getBeginMethodName());
     }
 
     /**
      * @see #getCurrentTestName()
      * @deprecated Use {@link #getCurrentTestName()} instead
      */
     protected String getCurrentTestMethod()
     {
         return getCurrentTestName();
     }
 
     /**
      * @return the name of the current test case being executed (it corresponds
      *         to the name of the test method with the "test" prefix removed.
      *         For example, for "testSomeTestOk" would return "someTestOk".
      */
     protected String getCurrentTestName()
     {
         return JUnitVersionHelper.getTestCaseName(getDelegatedTest());        
     }
 
     /**
      * @return The wrapped test name, if any (null otherwise).
      */
     public String getWrappedTestName()
     {
         if (isWrappingATest())
         {
             return getWrappedTest().getClass().getName();
         }
         return null;
     }
 
     /**
      * @return whether this test case wraps another
      */
     public boolean isWrappingATest()
     {
         return (getWrappedTest() != null);
     }
 }
 

1		/*
2		* ====================================================================
3		*
4		* The Apache Software License, Version 1.1
5		*
6		* Copyright (c) 2001-2003 The Apache Software Foundation. All rights
7		* reserved.
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		*
13		* 1. Redistributions of source code must retain the above copyright
14		* notice, this list of conditions and the following disclaimer.
15		*
16		* 2. Redistributions in binary form must reproduce the above copyright
17		* notice, this list of conditions and the following disclaimer in
18		* the documentation and/or other materials provided with the
19		* distribution.
20		*
21		* 3. The end-user documentation included with the redistribution, if
22		* any, must include the following acknowlegement:
23		* "This product includes software developed by the
24		* Apache Software Foundation (http://www.apache.org/)."
25		* Alternately, this acknowlegement may appear in the software itself,
26		* if and wherever such third-party acknowlegements normally appear.
27		*
28		* 4. The names "The Jakarta Project", "Cactus" and "Apache Software
29		* Foundation" must not be used to endorse or promote products
30		* derived from this software without prior written permission. For
31		* written permission, please contact apache@apache.org.
32		*
33		* 5. Products derived from this software may not be called "Apache"
34		* nor may "Apache" appear in their names without prior written
35		* permission of the Apache Group.
36		*
37		* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38		* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39		* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40		* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44		* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45		* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47		* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48		* SUCH DAMAGE.
49		* ====================================================================
50		*
51		* This software consists of voluntary contributions made by many
52		* individuals on behalf of the Apache Software Foundation. For more
53		* information on the Apache Software Foundation, please see
54		* <http://www.apache.org/>.
55		*
56		*/
57		package org.apache.cactus.internal.client;
58
59		import java.lang.reflect.InvocationTargetException;
60		import java.lang.reflect.Method;
61		import java.lang.reflect.Modifier;
62
63		import junit.framework.Assert;
64		import junit.framework.Test;
65
66		import org.apache.cactus.Request;
67		import org.apache.cactus.WebRequest;
68		import org.apache.cactus.configuration.Configuration;
69		import org.apache.cactus.util.JUnitVersionHelper;
70		import org.apache.commons.logging.Log;
71		import org.apache.commons.logging.LogFactory;
72
73		/**
74		* Delegate class that provides useful methods for the Cactus
75		* <code>XXXTestCase</code> classes. All the methods provided are independent
76		* of any communication protocol between client side and server side (HTTP,
77		* JMS, etc). Subclasses will define additional behaviour that depends on the
78		* protocol.
79		*
80		* It provides the ability to run common code before each test on the client
81		* side (note that calling common tear down code is delegated to child classes
82		* as the method signature depends on the protocol used).
83		*
84		* In addition it provides the ability to execute some one time (per-JVM)
85		* initialisation code (a pity this is not provided in JUnit). It can be
86		* useful to start an embedded server for example. Note: In the future this
87		* should be refatored and provided using a custom JUnit TestSuite.
88		*
89		* @author <a href="mailto:vmassol@apache.org">Vincent Massol</a>
90		*
91		* @version $Id: ClientTestCaseDelegate.java,v 1.2.2.1 2003/08/31 14:38:18 vmassol Exp $
92		*/
93		public class ClientTestCaseDelegate extends Assert
94		{
95		/**
96		* The prefix of a test method.
97		*/
98		protected static final String TEST_METHOD_PREFIX = "test";
99
100		/**
101		* The prefix of a begin test method.
102		*/
103		protected static final String BEGIN_METHOD_PREFIX = "begin";
104
105		/**
106		* The prefix of an end test method.
107		*/
108		protected static final String END_METHOD_PREFIX = "end";
109
110		/**
111		* The name of the method that is called before each test on the client
112		* side (if it exists).
113		*/
114		protected static final String CLIENT_GLOBAL_BEGIN_METHOD = "begin";
115
116		/**
117		* The name of the method that is called after each test on the client
118		* side (if it exists).
119		*/
120		protected static final String CLIENT_GLOBAL_END_METHOD = "end";
121
122		/**
123		* The logger (only used on the client side).
124		*/
125		private Log logger;
126
127		/**
128		* The Cactus configuration.
129		*/
130		private Configuration configuration;
131
132		/**
133		* Pure JUnit Test Case that we are wrapping (if any)
134		*/
135		private Test wrappedTest;
136
137		/**
138		* The test we are delegating for.
139		*/
140		private Test delegatedTest;
141
142		/**
143		* @param theDelegatedTest the test we are delegating for
144		* @param theWrappedTest the test being wrapped by this delegate (or null
145		* if none)
146		* @param theConfiguration the configuration to use
147		*/
148	0	public ClientTestCaseDelegate(Test theDelegatedTest,
149		Test theWrappedTest, Configuration theConfiguration)
150		{
151	0	if (theDelegatedTest == null)
152		{
153	0	throw new IllegalStateException(
154		"The test object passed must not be null");
155		}
156
157	0	setDelegatedTest(theDelegatedTest);
158	0	setWrappedTest(theWrappedTest);
159	0	setConfiguration(theConfiguration);
160		}
161
162		/**
163		* @param theWrappedTest the pure JUnit test that we need to wrap
164		*/
165	0	public void setWrappedTest(Test theWrappedTest)
166		{
167	0	this.wrappedTest = theWrappedTest;
168		}
169
170		/**
171		* @param theDelegatedTest the test we are delegating for
172		*/
173	0	public void setDelegatedTest(Test theDelegatedTest)
174		{
175	0	this.delegatedTest = theDelegatedTest;
176		}
177
178		/**
179		* @return the wrapped JUnit test
180		*/
181	0	public Test getWrappedTest()
182		{
183	0	return this.wrappedTest;
184		}
185
186		/**
187		* @return the test we are delegating for
188		*/
189	0	public Test getDelegatedTest()
190		{
191	0	return this.delegatedTest;
192		}
193
194		/**
195		* @return the test on which we will operate. If there is a wrapped
196		* test then the returned test is the wrapped test. Otherwise we
197		* return the delegated test.
198		*/
199	0	public Test getTest()
200		{
201	0	Test activeTest;
202	0	if (getWrappedTest() != null)
203		{
204	0	activeTest = getWrappedTest();
205		}
206		else
207		{
208	0	activeTest = getDelegatedTest();
209		}
210	0	return activeTest;
211		}
212
213
214		/**
215		* @return The logger used by the <code>TestCase</code> class and
216		* subclasses to perform logging.
217		*/
218	0	public final Log getLogger()
219		{
220	0	return this.logger;
221		}
222
223		/**
224		* @param theLogger the logger to use
225		*/
226	0	protected void setLogger(Log theLogger)
227		{
228	0	this.logger = theLogger;
229		}
230
231		/**
232		* @return the Cactus configuration
233		*/
234	0	public Configuration getConfiguration()
235		{
236	0	return this.configuration;
237		}
238
239		/**
240		* Sets the Cactus configuration
241		*
242		* @param theConfiguration the Cactus configuration
243		*/
244	0	public void setConfiguration(Configuration theConfiguration)
245		{
246	0	this.configuration = theConfiguration;
247		}
248
249		/**
250		* @return the name of the test method to call without the
251		* TEST_METHOD_PREFIX prefix
252		*/
253	0	private String getBaseMethodName()
254		{
255		// Sanity check
256	0	if (!getCurrentTestName().startsWith(TEST_METHOD_PREFIX))
257		{
258	0	throw new RuntimeException("bad name ["
259		+ getCurrentTestName()
260		+ "]. It should start with ["
261		+ TEST_METHOD_PREFIX + "].");
262		}
263
264	0	return getCurrentTestName().substring(
265		TEST_METHOD_PREFIX.length());
266		}
267
268		/**
269		* @return the name of the test begin method to call that initialize the
270		* test by initializing the <code>WebRequest</code> object
271		* for the test case.
272		*/
273	0	protected String getBeginMethodName()
274		{
275	0	return BEGIN_METHOD_PREFIX + getBaseMethodName();
276		}
277
278		/**
279		* @return the name of the test end method to call when the test has been
280		* run on the server. It can be used to verify returned headers,
281		* cookies, ...
282		*/
283	0	protected String getEndMethodName()
284		{
285	0	return END_METHOD_PREFIX + getBaseMethodName();
286		}
287
288		/**
289		* Perform client side initializations before each test, such as
290		* re-initializating the logger and printing some logging information.
291		*/
292	0	public void runBareInit()
293		{
294		// We make sure we reinitialize The logger with the name of the
295		// current extending class so that log statements will contain the
296		// actual class name (that's why the logged instance is not static).
297	0	this.logger = LogFactory.getLog(this.getClass());
298
299		// Mark beginning of test on client side
300	0	getLogger().debug("------------- Test: "
301		+ this.getCurrentTestName());
302		}
303
304		/**
305		* Call a begin method which takes Cactus WebRequest as parameter
306		*
307		* @param theRequest the request object which will contain data that will
308		* be used to connect to the Cactus server side redirectors.
309		* @param theMethodName the name of the begin method to call
310		* @exception Throwable any error that occurred when calling the method
311		*/
312	0	private void callGenericBeginMethod(Request theRequest,
313		String theMethodName) throws Throwable
314		{
315		// First, verify if a begin method exist. If one is found, verify if
316		// it has the correct signature. If not, send a warning.
317	0	Method[] methods = getTest().getClass().getMethods();
318
319	0	for (int i = 0; i < methods.length; i++)
320		{
321	0	if (methods[i].getName().equals(theMethodName))
322		{
323		// Check return type
324	0	if (!methods[i].getReturnType().getName().equals("void"))
325		{
326	0	fail("The method [" + methods[i].getName()
327		+ "] should return void and not ["
328		+ methods[i].getReturnType().getName() + "]");
329		}
330
331		// Check if method is public
332	0	if (!Modifier.isPublic(methods[i].getModifiers()))
333		{
334	0	fail("Method [" + methods[i].getName()
335		+ "] should be declared public");
336		}
337
338		// Check parameters
339	0	Class[] parameters = methods[i].getParameterTypes();
340
341	0	if (parameters.length != 1)
342		{
343	0	fail("The method [" + methods[i].getName()
344		+ "] must accept a single parameter derived from "
345		+ "class [" + WebRequest.class.getName() + "], "
346		+ "but " + parameters.length
347		+ " parameters were found");
348		}
349	0	else if (!theRequest.getClass().isAssignableFrom(parameters[0]))
350		{
351	0	fail("The method [" + methods[i].getName()
352		+ "] must accept a single parameter derived from "
353		+ "class [" + theRequest.getClass().getName() + "], "
354		+ "but found a [" + parameters[0].getName() + "] "
355		+ "parameter instead");
356		}
357
358	0	try
359		{
360	0	methods[i].invoke(getTest(), new Object[] {theRequest});
361
362	0	break;
363		}
364		catch (InvocationTargetException e)
365		{
366	0	e.fillInStackTrace();
367	0	throw e.getTargetException();
368		}
369		catch (IllegalAccessException e)
370		{
371	0	e.fillInStackTrace();
372	0	throw e;
373		}
374		}
375		}
376		}
377
378		/**
379		* Call the global begin method. This is the method that is called before
380		* each test if it exists. It is called on the client side only.
381		*
382		* @param theRequest the request object which will contain data that will
383		* be used to connect to the Cactus server side redirectors.
384		* @exception Throwable any error that occurred when calling the method
385		*/
386	0	protected void callClientGlobalBegin(Request theRequest) throws Throwable
387		{
388	0	callGenericBeginMethod(theRequest, CLIENT_GLOBAL_BEGIN_METHOD);
389		}
390
391		/**
392		* Call the test case begin method.
393		*
394		* @param theRequest the request object to pass to the begin method.
395		* @exception Throwable any error that occurred when calling the begin
396		* method for the current test case.
397		*/
398	0	public void callBeginMethod(Request theRequest) throws Throwable
399		{
400	0	callGenericBeginMethod(theRequest, getBeginMethodName());
401		}
402
403		/**
404		* @see #getCurrentTestName()
405		* @deprecated Use {@link #getCurrentTestName()} instead
406		*/
407	0	protected String getCurrentTestMethod()
408		{
409	0	return getCurrentTestName();
410		}
411
412		/**
413		* @return the name of the current test case being executed (it corresponds
414		* to the name of the test method with the "test" prefix removed.
415		* For example, for "testSomeTestOk" would return "someTestOk".
416		*/
417	0	protected String getCurrentTestName()
418		{
419	0	return JUnitVersionHelper.getTestCaseName(getDelegatedTest());
420		}
421
422		/**
423		* @return The wrapped test name, if any (null otherwise).
424		*/
425	0	public String getWrappedTestName()
426		{
427	0	if (isWrappingATest())
428		{
429	0	return getWrappedTest().getClass().getName();
430		}
431	0	return null;
432		}
433
434		/**
435		* @return whether this test case wraps another
436		*/
437	0	public boolean isWrappingATest()
438		{
439	0	return (getWrappedTest() != null);
440		}
441		}
442