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:	405		Methods:	21
	NCLOC:	222		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

AbstractTestSuite.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;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Enumeration;
 import java.util.Vector;
 
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestResult;
 
 /**
  * Test Suite that wraps all the tests of the suite in Cactus Test Case 
  * objects so that pure JUnit tests can be run on the server side.
  *
  * @author <a href="mailto:vmassol@apache.org">Vincent Massol</a>
  *
  * @version $Id: AbstractTestSuite.java,v 1.6 2003/07/12 16:08:12 vmassol Exp $
  * @since 1.5
  */
 public abstract class AbstractTestSuite implements Test
 {
     /**
      * Lists of tests to execute (Test objects)
      */
     private Vector tests = new Vector(10);
 
     /**
      * Name of the current test suite
      */
     private String name;
     
     /**
      * @see junit.framework.TestSuite#TestSuite()
      */
     public AbstractTestSuite()
     {
     }
 
     /**
      * @see junit.framework.TestSuite#TestSuite(Class)
      */
     public AbstractTestSuite(final Class theClass)
     {
         setName(theClass.getName());
         Constructor constructor;
         try
         {
             // Avoid generating multiple error messages
             constructor = getTestConstructor(theClass); 
         }
         catch (NoSuchMethodException e)
         {
             addTest(warning("Class " + theClass.getName()
                 + " has no public constructor TestCase(String name)"));
             return;
         }
 
         if (!Modifier.isPublic(theClass.getModifiers()))
         {
             addTest(warning("Class " + theClass.getName() + " is not public"));
             return;
         }
 
         Class superClass = theClass;
         Vector names = new Vector();
         while (Test.class.isAssignableFrom(superClass))
         {
             Method[] methods = superClass.getDeclaredMethods();
             for (int i = 0; i < methods.length; i++)
             {
                 addTestMethod(methods[i], names, constructor);
             }
             superClass = superClass.getSuperclass();
         }
         if (this.tests.size() == 0)
         {
             addTest(warning("No tests found in " + theClass.getName()));
         }
     }
 
     /**
      * @see junit.framework.TestSuite#TestSuite(String)
      */
     public AbstractTestSuite(String theName)
     {
         setName(theName);
     }
 
     /**
      * @see junit.framework.TestSuite#addTest(Test)
      */
     public void addTest(Test theTest)
     {
         this.tests.addElement(theTest);
     }
 
     /**
      * @see junit.framework.TestSuite#addTestSuite(Class)
      */
     public void addTestSuite(Class theTestClass)
     {
         addTest(createTestSuite(theTestClass));
     }
 
     /**
      * @see junit.framework.TestSuite#addTestMethod(Method, Vector, Constructor)
      */
     private void addTestMethod(Method theMethod, Vector theNames, 
         Constructor theConstructor)
     {
         String name = theMethod.getName();
         if (theNames.contains(name))
         {
             return;
         }
         if (isPublicTestMethod(theMethod))
         {
             theNames.addElement(name);
 
             try
             {
                 // Note: We wrap the Test in a Cactus Test Case
                 Object constructorInstance;
                 if (theConstructor.getParameterTypes().length == 0)
                 {
                     constructorInstance = theConstructor.newInstance(
                         new Object[0]);
                     if (constructorInstance instanceof TestCase)
                     {
                         ((TestCase) constructorInstance).setName(name);
                     }
                 }
                 else
                 {
                     constructorInstance = theConstructor.newInstance(
                         new Object[] {name});
                 }
                 addTest(new ServletTestCase(name, (Test) constructorInstance));
             }
             catch (InstantiationException e)
             {
                 addTest(warning("Cannot instantiate test case: " + name
                     + " (" + exceptionToString(e) + ")"));
             }
             catch (InvocationTargetException e)
             {
                 addTest(warning("Exception in constructor: " + name + " (" 
                     + exceptionToString(e.getTargetException()) + ")"));
             }
             catch (IllegalAccessException e)
             {
                 addTest(warning("Cannot access test case: " + name + " ("
                     + exceptionToString(e) + ")"));
             }
         }
         else
         { 
             // Almost a test method
             if (isTestMethod(theMethod))
             {
                 addTest(warning("Test method isn't public: " 
                     + theMethod.getName()));
             }
         }
     }
 
     /**
      * @see junit.framework.TestSuite#exceptionToString(Throwable)
      */
     private String exceptionToString(Throwable theThrowable)
     {
         StringWriter stringWriter = new StringWriter();
         PrintWriter writer = new PrintWriter(stringWriter);
         theThrowable.printStackTrace(writer);
         return stringWriter.toString();
     }
 
     /**
      * @see junit.framework.TestSuite#countTestCases()
      */
     public int countTestCases()
     {
         int count = 0;
         for (Enumeration e = tests(); e.hasMoreElements();)
         {
             Test test = (Test) e.nextElement();
             count = count + test.countTestCases();
         }
         return count;
     }
 
     /**
      * @see junit.framework.TestSuite#isPublicTestMethod(Method)
      */
     private boolean isPublicTestMethod(Method theMethod)
     {
         return isTestMethod(theMethod) 
             && Modifier.isPublic(theMethod.getModifiers());
     }
 
     /**
      * @see junit.framework.TestSuite#isTestMethod(Method)
      */
     private boolean isTestMethod(Method theMethod)
     {
         String name = theMethod.getName();
         Class[] parameters = theMethod.getParameterTypes();
         Class returnType = theMethod.getReturnType();
         return parameters.length == 0
             && name.startsWith("test")
             && returnType.equals(Void.TYPE);
     }
 
     /**
      * @see junit.framework.TestSuite#run(TestResult)
      */
     public void run(TestResult theResult)
     {
         for (Enumeration e = tests(); e.hasMoreElements();)
         {
             if (theResult.shouldStop())
             {
                 break;
             }
             Test test = (Test) e.nextElement();
             runTest(test, theResult);
         }
     }
     
     /**
      * @see junit.framework.TestSuite#runTest(Test, TestResult)
      */
     public void runTest(Test theTest, TestResult theResult)
     {
         theTest.run(theResult);
     }
     
     /**
      * @see junit.framework.TestSuite#testAt(int)
      */
     public Test testAt(int theIndex)
     {
         return (Test) this.tests.elementAt(theIndex);
     }
 
     /**
      * Gets a constructor which takes a single String as
      * its argument or a no arg constructor.
      * 
      * @param theClass the class for which to find the constructor
      * @return the valid constructor found
      * @exception NoSuchMethodException if no valid constructor is
      *            found
      */
     public static Constructor getTestConstructor(Class theClass) 
         throws NoSuchMethodException
     {
         Class[] args = {String.class};
         try
         {
             return theClass.getConstructor(args);   
         }
         catch (NoSuchMethodException e)
         {
             // fall through
         }
         return theClass.getConstructor(new Class[0]);
     }
 
     /**
      * @see junit.framework.TestSuite#testCount()
      */
     public int testCount()
     {
         return this.tests.size();
     }
 
     /**
      * @see junit.framework.TestSuite#tests()
      */
     public Enumeration tests()
     {
         return this.tests.elements();
     }
 
     /**
      * @see junit.framework.TestSuite#toString()
      */
     public String toString()
     {
         if (getName() != null)
         {
             return getName();
         }
         return super.toString();
     }
 
     /**
      * @see junit.framework.TestSuite#setName(String)
      */
     public void setName(String theName)
     {
         this.name = theName;
     }
 
     /**
      * @see junit.framework.TestSuite#getName()
      */
     public String getName()
     {
         return this.name;
     }
 
     /**
      * @see junit.framework.TestSuite#warning(String)
      */
     private static Test warning(final String theMessage)
     {
         return new TestCase("warning")
         {
             protected void runTest()
             {
                 fail(theMessage);
             }
         };
     }
 
     /**
      * @param theTestClass the test class containing the tests to be included
      *        in the Cactus Test Suite
      * @return a Cactus Test Suite (ex: ServletTestSuite) initialized with a
      *         test class
      */
     protected abstract Test createTestSuite(Class theTestClass);
 
     /**
      * @param theName the name of the Cactus Test Case
      * @param theTest the wrapped test
      * @return a Cactus Test Case object initialized with the give name and
      *         wrapped test
      */
     protected abstract Test createCactusTestCase(String theName, Test theTest);
 }
 

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;
58
59		import java.io.PrintWriter;
60		import java.io.StringWriter;
61		import java.lang.reflect.Constructor;
62		import java.lang.reflect.InvocationTargetException;
63		import java.lang.reflect.Method;
64		import java.lang.reflect.Modifier;
65		import java.util.Enumeration;
66		import java.util.Vector;
67
68		import junit.framework.Test;
69		import junit.framework.TestCase;
70		import junit.framework.TestResult;
71
72		/**
73		* Test Suite that wraps all the tests of the suite in Cactus Test Case
74		* objects so that pure JUnit tests can be run on the server side.
75		*
76		* @author <a href="mailto:vmassol@apache.org">Vincent Massol</a>
77		*
78		* @version $Id: AbstractTestSuite.java,v 1.6 2003/07/12 16:08:12 vmassol Exp $
79		* @since 1.5
80		*/
81		public abstract class AbstractTestSuite implements Test
82		{
83		/**
84		* Lists of tests to execute (Test objects)
85		*/
86		private Vector tests = new Vector(10);
87
88		/**
89		* Name of the current test suite
90		*/
91		private String name;
92
93		/**
94		* @see junit.framework.TestSuite#TestSuite()
95		*/
96	0	public AbstractTestSuite()
97		{
98		}
99
100		/**
101		* @see junit.framework.TestSuite#TestSuite(Class)
102		*/
103	0	public AbstractTestSuite(final Class theClass)
104		{
105	0	setName(theClass.getName());
106	0	Constructor constructor;
107	0	try
108		{
109		// Avoid generating multiple error messages
110	0	constructor = getTestConstructor(theClass);
111		}
112		catch (NoSuchMethodException e)
113		{
114	0	addTest(warning("Class " + theClass.getName()
115		+ " has no public constructor TestCase(String name)"));
116	0	return;
117		}
118
119	0	if (!Modifier.isPublic(theClass.getModifiers()))
120		{
121	0	addTest(warning("Class " + theClass.getName() + " is not public"));
122	0	return;
123		}
124
125	0	Class superClass = theClass;
126	0	Vector names = new Vector();
127	0	while (Test.class.isAssignableFrom(superClass))
128		{
129	0	Method[] methods = superClass.getDeclaredMethods();
130	0	for (int i = 0; i < methods.length; i++)
131		{
132	0	addTestMethod(methods[i], names, constructor);
133		}
134	0	superClass = superClass.getSuperclass();
135		}
136	0	if (this.tests.size() == 0)
137		{
138	0	addTest(warning("No tests found in " + theClass.getName()));
139		}
140		}
141
142		/**
143		* @see junit.framework.TestSuite#TestSuite(String)
144		*/
145	0	public AbstractTestSuite(String theName)
146		{
147	0	setName(theName);
148		}
149
150		/**
151		* @see junit.framework.TestSuite#addTest(Test)
152		*/
153	0	public void addTest(Test theTest)
154		{
155	0	this.tests.addElement(theTest);
156		}
157
158		/**
159		* @see junit.framework.TestSuite#addTestSuite(Class)
160		*/
161	0	public void addTestSuite(Class theTestClass)
162		{
163	0	addTest(createTestSuite(theTestClass));
164		}
165
166		/**
167		* @see junit.framework.TestSuite#addTestMethod(Method, Vector, Constructor)
168		*/
169	0	private void addTestMethod(Method theMethod, Vector theNames,
170		Constructor theConstructor)
171		{
172	0	String name = theMethod.getName();
173	0	if (theNames.contains(name))
174		{
175	0	return;
176		}
177	0	if (isPublicTestMethod(theMethod))
178		{
179	0	theNames.addElement(name);
180
181	0	try
182		{
183		// Note: We wrap the Test in a Cactus Test Case
184	0	Object constructorInstance;
185	0	if (theConstructor.getParameterTypes().length == 0)
186		{
187	0	constructorInstance = theConstructor.newInstance(
188		new Object[0]);
189	0	if (constructorInstance instanceof TestCase)
190		{
191	0	((TestCase) constructorInstance).setName(name);
192		}
193		}
194		else
195		{
196	0	constructorInstance = theConstructor.newInstance(
197		new Object[] {name});
198		}
199	0	addTest(new ServletTestCase(name, (Test) constructorInstance));
200		}
201		catch (InstantiationException e)
202		{
203	0	addTest(warning("Cannot instantiate test case: " + name
204		+ " (" + exceptionToString(e) + ")"));
205		}
206		catch (InvocationTargetException e)
207		{
208	0	addTest(warning("Exception in constructor: " + name + " ("
209		+ exceptionToString(e.getTargetException()) + ")"));
210		}
211		catch (IllegalAccessException e)
212		{
213	0	addTest(warning("Cannot access test case: " + name + " ("
214		+ exceptionToString(e) + ")"));
215		}
216		}
217		else
218		{
219		// Almost a test method
220	0	if (isTestMethod(theMethod))
221		{
222	0	addTest(warning("Test method isn't public: "
223		+ theMethod.getName()));
224		}
225		}
226		}
227
228		/**
229		* @see junit.framework.TestSuite#exceptionToString(Throwable)
230		*/
231	0	private String exceptionToString(Throwable theThrowable)
232		{
233	0	StringWriter stringWriter = new StringWriter();
234	0	PrintWriter writer = new PrintWriter(stringWriter);
235	0	theThrowable.printStackTrace(writer);
236	0	return stringWriter.toString();
237		}
238
239		/**
240		* @see junit.framework.TestSuite#countTestCases()
241		*/
242	0	public int countTestCases()
243		{
244	0	int count = 0;
245	0	for (Enumeration e = tests(); e.hasMoreElements();)
246		{
247	0	Test test = (Test) e.nextElement();
248	0	count = count + test.countTestCases();
249		}
250	0	return count;
251		}
252
253		/**
254		* @see junit.framework.TestSuite#isPublicTestMethod(Method)
255		*/
256	0	private boolean isPublicTestMethod(Method theMethod)
257		{
258	0	return isTestMethod(theMethod)
259		&& Modifier.isPublic(theMethod.getModifiers());
260		}
261
262		/**
263		* @see junit.framework.TestSuite#isTestMethod(Method)
264		*/
265	0	private boolean isTestMethod(Method theMethod)
266		{
267	0	String name = theMethod.getName();
268	0	Class[] parameters = theMethod.getParameterTypes();
269	0	Class returnType = theMethod.getReturnType();
270	0	return parameters.length == 0
271		&& name.startsWith("test")
272		&& returnType.equals(Void.TYPE);
273		}
274
275		/**
276		* @see junit.framework.TestSuite#run(TestResult)
277		*/
278	0	public void run(TestResult theResult)
279		{
280	0	for (Enumeration e = tests(); e.hasMoreElements();)
281		{
282	0	if (theResult.shouldStop())
283		{
284	0	break;
285		}
286	0	Test test = (Test) e.nextElement();
287	0	runTest(test, theResult);
288		}
289		}
290
291		/**
292		* @see junit.framework.TestSuite#runTest(Test, TestResult)
293		*/
294	0	public void runTest(Test theTest, TestResult theResult)
295		{
296	0	theTest.run(theResult);
297		}
298
299		/**
300		* @see junit.framework.TestSuite#testAt(int)
301		*/
302	0	public Test testAt(int theIndex)
303		{
304	0	return (Test) this.tests.elementAt(theIndex);
305		}
306
307		/**
308		* Gets a constructor which takes a single String as
309		* its argument or a no arg constructor.
310		*
311		* @param theClass the class for which to find the constructor
312		* @return the valid constructor found
313		* @exception NoSuchMethodException if no valid constructor is
314		* found
315		*/
316	0	public static Constructor getTestConstructor(Class theClass)
317		throws NoSuchMethodException
318		{
319	0	Class[] args = {String.class};
320	0	try
321		{
322	0	return theClass.getConstructor(args);
323		}
324		catch (NoSuchMethodException e)
325		{
326		// fall through
327		}
328	0	return theClass.getConstructor(new Class[0]);
329		}
330
331		/**
332		* @see junit.framework.TestSuite#testCount()
333		*/
334	0	public int testCount()
335		{
336	0	return this.tests.size();
337		}
338
339		/**
340		* @see junit.framework.TestSuite#tests()
341		*/
342	0	public Enumeration tests()
343		{
344	0	return this.tests.elements();
345		}
346
347		/**
348		* @see junit.framework.TestSuite#toString()
349		*/
350	0	public String toString()
351		{
352	0	if (getName() != null)
353		{
354	0	return getName();
355		}
356	0	return super.toString();
357		}
358
359		/**
360		* @see junit.framework.TestSuite#setName(String)
361		*/
362	0	public void setName(String theName)
363		{
364	0	this.name = theName;
365		}
366
367		/**
368		* @see junit.framework.TestSuite#getName()
369		*/
370	0	public String getName()
371		{
372	0	return this.name;
373		}
374
375		/**
376		* @see junit.framework.TestSuite#warning(String)
377		*/
378	0	private static Test warning(final String theMessage)
379		{
380	0	return new TestCase("warning")
381		{
382	0	protected void runTest()
383		{
384	0	fail(theMessage);
385		}
386		};
387		}
388
389		/**
390		* @param theTestClass the test class containing the tests to be included
391		* in the Cactus Test Suite
392		* @return a Cactus Test Suite (ex: ServletTestSuite) initialized with a
393		* test class
394		*/
395		protected abstract Test createTestSuite(Class theTestClass);
396
397		/**
398		* @param theName the name of the Cactus Test Case
399		* @param theTest the wrapped test
400		* @return a Cactus Test Case object initialized with the give name and
401		* wrapped test
402		*/
403		protected abstract Test createCactusTestCase(String theName, Test theTest);
404		}
405