TestCase


1   package junit.framework;
2   
3   import java.lang.reflect.InvocationTargetException  ;
4   import java.lang.reflect.Method  ;
5   import java.lang.reflect.Modifier  ;
6   
7   /**
8    * A test case defines the fixture to run multiple tests. To define a test case<br/>
9    * <ol>
10   *   <li>implement a subclass of <code>TestCase</code></li>
11   *   <li>define instance variables that store the state of the fixture</li>
12   *   <li>initialize the fixture state by overriding {@link #setUp()}</li>
13   *   <li>clean-up after a test by overriding {@link #tearDown()}.</li>
14   * </ol>
15   * Each test runs in its own fixture so there
16   * can be no side effects among test runs.
17   * Here is an example:
18   * <pre>
19   * public class MathTest extends TestCase {
20   *    protected double fValue1;
21   *    protected double fValue2;
22   *
23   *    protected void setUp() {
24   *       fValue1= 2.0;
25   *       fValue2= 3.0;
26   *    }
27   * }
28   * </pre>
29   *
30   * For each test implement a method which interacts
31   * with the fixture. Verify the expected results with assertions specified
32   * by calling {@link junit.framework.Assert#assertTrue(String, boolean)} with a boolean.
33   * <pre>
34   *    public void testAdd() {
35   *       double result= fValue1 + fValue2;
36   *       assertTrue(result == 5.0);
37   *    }
38   * </pre>
39   * 
40   * Once the methods are defined you can run them. The framework supports
41   * both a static type safe and more dynamic way to run a test.
42   * In the static way you override the runTest method and define the method to
43   * be invoked. A convenient way to do so is with an anonymous inner class.
44   * <pre>
45   * TestCase test= new MathTest("add") {
46   *    public void runTest() {
47   *       testAdd();
48   *    }
49   * };
50   * test.run();
51   * </pre>
52   * 
53   * The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds
54   * and invokes a method.
55   * In this case the name of the test case has to correspond to the test method
56   * to be run.
57   * <pre>
58   * TestCase test= new MathTest("testAdd");
59   * test.run();
60   * </pre>
61   * 
62   * The tests to be run can be collected into a TestSuite. JUnit provides
63   * different <i>test runners</i> which can run a test suite and collect the results.
64   * A test runner either expects a static method <code>suite</code> as the entry
65   * point to get a test to run or it will extract the suite automatically.
66   * <pre>
67   * public static Test suite() {
68   *    suite.addTest(new MathTest("testAdd"));
69   *    suite.addTest(new MathTest("testDivideByZero"));
70   *    return suite;
71   * }
72   * </pre>
73   * @see TestResult
74   * @see TestSuite
75   */
76  public abstract class TestCase extends Assert implements Test {
77      /**
78       * the name of the test case
79       */
80      private String   fName;
81  
82      /**
83       * No-arg constructor to enable serialization. This method
84       * is not intended to be used by mere mortals without calling setName().
85       */
86      public TestCase() {
87          fName= null;
88      }
89      /**
90       * Constructs a test case with the given name.
91       */
92      public TestCase(String   name) {
93          fName= name;
94      }
95      /**
96       * Counts the number of test cases executed by run(TestResult result).
97       */
98      public int countTestCases() {
99          return 1;
100     }
101     /**
102      * Creates a default TestResult object
103      *
104      * @see TestResult
105      */
106     protected TestResult createResult() {
107         return new TestResult();
108     }
109     /**
110      * A convenience method to run this test, collecting the results with a
111      * default TestResult object.
112      *
113      * @see TestResult
114      */
115     public TestResult run() {
116         TestResult result= createResult();
117         run(result);
118         return result;
119     }
120     /**
121      * Runs the test case and collects the results in TestResult.
122      */
123     public void run(TestResult result) {
124         result.run(this);
125     }
126     /**
127      * Runs the bare test sequence.
128      * @throws Throwable if any exception is thrown
129      */
130     public void runBare() throws Throwable   {
131         Throwable   exception= null;
132         setUp();
133         try {
134             runTest();
135         } catch (Throwable   running) {
136             exception= running;
137         }
138         finally {
139             try {
140                 tearDown();
141             } catch (Throwable   tearingDown) {
142                 if (exception == null) exception= tearingDown;
143             }
144         }
145         if (exception != null) throw exception;
146     }
147     /**
148      * Override to run the test and assert its state.
149      * @throws Throwable if any exception is thrown
150      */
151     protected void runTest() throws Throwable   {
152         assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
153         Method   runMethod= null;
154         try {
155             // use getMethod to get all public inherited
156             // methods. getDeclaredMethods returns all
157             // methods of this class but excludes the
158             // inherited ones.
159             runMethod= getClass().getMethod(fName, (Class  [])null);
160         } catch (NoSuchMethodException   e) {
161             fail("Method \""+fName+"\" not found");
162         }
163         if (!Modifier.isPublic(runMethod.getModifiers())) {
164             fail("Method \""+fName+"\" should be public");
165         }
166 
167         try {
168             runMethod.invoke(this);
169         }
170         catch (InvocationTargetException   e) {
171             e.fillInStackTrace();
172             throw e.getTargetException();
173         }
174         catch (IllegalAccessException   e) {
175             e.fillInStackTrace();
176             throw e;
177         }
178     }
179     /**
180      * Sets up the fixture, for example, open a network connection.
181      * This method is called before a test is executed.
182      */
183     protected void setUp() throws Exception   {
184     }
185     /**
186      * Tears down the fixture, for example, close a network connection.
187      * This method is called after a test is executed.
188      */
189     protected void tearDown() throws Exception   {
190     }
191     /**
192      * Returns a string representation of the test case
193      */
194     @Override  
195     public String   toString() {
196         return getName() + "(" + getClass().getName() + ")";
197     }
198     /**
199      * Gets the name of a TestCase
200      * @return the name of the TestCase
201      */
202     public String   getName() {
203         return fName;
204     }
205     /**
206      * Sets the name of a TestCase
207      * @param name the name to set
208      */
209     public void setName(String   name) {
210         fName= name;
211     }
212 }
213
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags