Clover coverage report - clover
Coverage timestamp: Sat Oct 8 2005 22:54:17 EDT
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 332   Methods: 33
NCLOC: 302   Classes: 7
 
 Source file Conditionals Statements Methods TOTAL
StepRunnerTest.java 100% 93.8% 84.8% 92.3%
coverage coverage
 1    
 package abbot.script;
 2    
 
 3    
 import java.io.*;
 4    
 import java.util.ArrayList;
 5    
 import javax.swing.*;
 6    
 
 7    
 import junit.extensions.abbot.*;
 8    
 import abbot.AssertionFailedError;
 9    
 import abbot.finder.AWTHierarchy;
 10    
 
 11    
 public class StepRunnerTest extends ResolverFixture {
 12    
 
 13    
     private StepRunner runner;
 14    
     private ArrayList events;
 15    
     private Resolver resolver;
 16    
 
 17  11 
     protected void setUp() {
 18  11 
         events = new ArrayList();
 19  11 
         resolver = getResolver();
 20  11 
         runner = new StepRunner();
 21  11 
         runner.addStepListener(new StepListener() {
 22  36 
             public void stateChanged(StepEvent ev) {
 23  36 
                 events.add(ev);
 24    
             }
 25    
         });
 26    
     }
 27    
 
 28  11 
     protected void tearDown() {
 29  11 
         runner.terminate();
 30  11 
         runner = null;
 31  11 
         events = null;
 32  11 
         resolver = null;
 33    
     }
 34    
 
 35  1 
     public void testRunStep() throws Throwable {
 36  1 
         runner.runStep(new DefaultStep("simple step"));
 37  1 
         assertEquals("Wrong number of step events generated",
 38    
                      2, events.size());
 39  1 
         assertEquals("Missing step start",
 40    
                      StepEvent.STEP_START,
 41    
                      ((StepEvent)events.get(0)).getType());
 42  1 
         assertEquals("Missing step end",
 43    
                      StepEvent.STEP_END,
 44    
                      ((StepEvent)events.get(1)).getType());
 45    
     }
 46    
 
 47  1 
     public void testRunSequence() throws Throwable {
 48  1 
         Sequence seq = new Sequence(getResolver(), "sequence of 2", null);
 49  1 
         Step st1 = new DefaultStep("step 1");
 50  1 
         seq.addStep(st1);
 51  1 
         Step st2 = new DefaultStep("step 2");
 52  1 
         seq.addStep(st2);
 53  1 
         runner.runStep(seq);
 54  1 
         assertEquals("Wrong number of step events generated",
 55    
                      6, events.size());
 56  1 
         assertEquals("Missing sequence start",
 57    
                      StepEvent.STEP_START,
 58    
                      ((StepEvent)events.get(0)).getType());
 59  1 
         assertEquals("Expected sequence start, wrong source",
 60    
                      seq, ((StepEvent)events.get(0)).getStep());
 61  1 
         assertEquals("Missing step 1 start",
 62    
                      StepEvent.STEP_START,
 63    
                      ((StepEvent)events.get(1)).getType());
 64  1 
         assertEquals("Wrong source",
 65    
                      st1, ((StepEvent)events.get(1)).getStep());
 66  1 
         assertEquals("Missing step 1 end",
 67    
                      StepEvent.STEP_END,
 68    
                      ((StepEvent)events.get(2)).getType());
 69  1 
         assertEquals("Wrong source",
 70    
                      st2, ((StepEvent)events.get(3)).getStep());
 71  1 
         assertEquals("Missing step 2 start",
 72    
                      StepEvent.STEP_START,
 73    
                      ((StepEvent)events.get(3)).getType());
 74  1 
         assertEquals("Missing step 2 end",
 75    
                      StepEvent.STEP_END,
 76    
                      ((StepEvent)events.get(4)).getType());
 77  1 
         assertEquals("Missing sequence end",
 78    
                      StepEvent.STEP_END,
 79    
                      ((StepEvent)events.get(5)).getType());
 80    
     }
 81    
 
 82  1 
     public void testRunFailedStep() throws Throwable {
 83  1 
         Step step = new FailingStep("fail");
 84  1 
         Throwable failure = null;
 85  1 
         try {
 86  1 
             runner.runStep(step);
 87    
         }
 88    
         catch(AssertionFailedError afe) {
 89  1 
             failure = afe;
 90    
         }
 91  1 
         assertTrue("step failure should have been caught",
 92    
                    runner.getError(step) != null);
 93  1 
         assertEquals("wrong failure", failure, runner.getError(step));
 94  1 
         assertEquals("Wrong number of events", 2, events.size());
 95  1 
         assertEquals("Missing step start", StepEvent.STEP_START,
 96    
                      ((StepEvent)events.get(0)).getType());
 97  1 
         assertEquals("Missing step failure", StepEvent.STEP_FAILURE,
 98    
                      ((StepEvent)events.get(1)).getType());
 99    
     }
 100    
 
 101  1 
     public void testRunFailedSequence() throws Throwable {
 102  1 
         Sequence seq = new Sequence(getResolver(), "sequence of 1", null);
 103  1 
         Step step = new FailingStep("fail");
 104  1 
         seq.addStep(step);
 105  1 
         Throwable failure = null;
 106  1 
         try {
 107  1 
             runner.runStep(seq);
 108    
         }
 109    
         catch(AssertionFailedError afe) {
 110  1 
             failure = afe;
 111    
         }
 112  1 
         assertTrue("step failure should have been caught",
 113    
                    runner.getError(step) != null);
 114  1 
         assertEquals("wrong failure", failure, runner.getError(step));
 115  1 
         assertEquals("Wrong number of events", 4, events.size());
 116  1 
         assertEquals("Missing sequence start", StepEvent.STEP_START,
 117    
                      ((StepEvent)events.get(0)).getType());
 118  1 
         assertEquals("Wrong event source", seq,
 119    
                      ((StepEvent)events.get(0)).getStep());
 120  1 
         assertEquals("Missing step start", StepEvent.STEP_START,
 121    
                      ((StepEvent)events.get(1)).getType());
 122  1 
         assertEquals("Wrong event source", step,
 123    
                      ((StepEvent)events.get(1)).getStep());
 124  1 
         assertEquals("Missing step failure", StepEvent.STEP_FAILURE,
 125    
                      ((StepEvent)events.get(2)).getType());
 126  1 
         assertEquals("Wrong event source", step,
 127    
                      ((StepEvent)events.get(2)).getStep());
 128  1 
         assertEquals("Missing step failure", StepEvent.STEP_FAILURE,
 129    
                      ((StepEvent)events.get(3)).getType());
 130  1 
         assertEquals("Wrong event source", seq,
 131    
                      ((StepEvent)events.get(3)).getStep());
 132    
     }
 133    
 
 134  1 
     public void testRunErrorStep() {
 135  1 
         Step step = new ErrorStep("error");
 136  1 
         Throwable error = null;
 137  1 
         try {
 138  1 
             runner.runStep(step);
 139    
         }
 140    
         catch(Throwable thr) {
 141  1 
             error = thr;
 142    
         }
 143  1 
         assertNotNull("step error should have been caught", error);
 144  1 
         assertNotNull("step error should be stored with runner",
 145    
                       runner.getError(step));
 146  1 
         assertEquals("wrong error", error, runner.getError(step));
 147  1 
         assertEquals("Wrong number of events", 2, events.size());
 148  1 
         assertEquals("Missing step start", StepEvent.STEP_START,
 149    
                      ((StepEvent)events.get(0)).getType());
 150  1 
         assertEquals("Missing step failure", StepEvent.STEP_ERROR,
 151    
                      ((StepEvent)events.get(1)).getType());
 152    
     }
 153    
 
 154  1 
     public void testRunEDTError() {
 155  1 
         Step step = new EDTErrorStep();
 156  1 
         Throwable error = null;
 157  1 
         try {
 158  1 
             runner.runStep(step);
 159    
         }
 160    
         catch(Throwable t) {
 161  1 
             error = t;
 162    
         }
 163  1 
         assertNotNull("EDT error should have been thrown by runner", error);
 164  1 
         assertNotNull("EDT error should be stored with runner",
 165    
                       runner.getError(step));
 166    
     }
 167    
 
 168  1 
     public void testRunErrorSequence() throws Throwable {
 169  1 
         Sequence seq = new Sequence(getResolver(), "sequence of 1", null);
 170  1 
         Step step = new ErrorStep("error");
 171  1 
         seq.addStep(step);
 172  1 
         Throwable failure = null;
 173  1 
         try {
 174  1 
             runner.runStep(seq);
 175    
         }
 176    
         catch(Throwable thr) {
 177  1 
             failure = thr;
 178    
         }
 179  1 
         assertTrue("step error should have been caught",
 180    
                    runner.getError(step) != null);
 181  1 
         assertEquals("wrong failure", failure, runner.getError(step));
 182  1 
         assertEquals("Wrong number of events", 4, events.size());
 183  1 
         assertEquals("Missing sequence start", StepEvent.STEP_START,
 184    
                      ((StepEvent)events.get(0)).getType());
 185  1 
         assertEquals("Wrong event source", seq,
 186    
                      ((StepEvent)events.get(0)).getStep());
 187  1 
         assertEquals("Missing step start", StepEvent.STEP_START,
 188    
                      ((StepEvent)events.get(1)).getType());
 189  1 
         assertEquals("Wrong event source", step,
 190    
                      ((StepEvent)events.get(1)).getStep());
 191  1 
         assertEquals("Missing step failure", StepEvent.STEP_ERROR,
 192    
                      ((StepEvent)events.get(2)).getType());
 193  1 
         assertEquals("Wrong event source", step,
 194    
                      ((StepEvent)events.get(2)).getStep());
 195  1 
         assertEquals("Missing step failure", StepEvent.STEP_ERROR,
 196    
                      ((StepEvent)events.get(3)).getType());
 197  1 
         assertEquals("Wrong event source", seq,
 198    
                      ((StepEvent)events.get(3)).getStep());
 199    
     }
 200    
 
 201    
     /** If the script is set to run to completion, make sure it throws an
 202    
      * error at the end.
 203    
      */
 204  1 
     public void testThrowMultipleError() throws Throwable {
 205  1 
         Sequence seq = new Sequence(getResolver(), "sequence of 2", null);
 206  1 
         Step error1 = new ErrorStep("error 1");
 207  1 
         seq.addStep(error1);
 208  1 
         Step error2 = new ErrorStep("error 2");
 209  1 
         seq.addStep(error2);
 210  1 
         runner.setStopOnError(false);
 211  1 
         try {
 212  1 
             runner.runStep(seq);
 213    
         }
 214    
         catch(Throwable thr) {
 215  0 
             StepEvent lastEvent = (StepEvent)events.get(events.size()-1);
 216  0 
             assertEquals("No error on event", thr, lastEvent.getError());
 217  0 
             assertEquals("Wrong event source", seq, lastEvent.getStep());
 218    
         }
 219    
     }
 220    
 
 221  1 
     public void testNoTerminate() throws Throwable {
 222  1 
         Script script = new Script(getHierarchy());
 223  1 
         final JFrame f = new JFrame(getName());
 224  1 
         f.getContentPane().add(new JLabel(getName()));
 225  1 
         script.addStep(new DefaultStep("Window Shower") {
 226  1 
             public void runStep() {
 227  1 
                 f.show();
 228    
             }
 229    
         });
 230  1 
         runner.run(script);
 231  1 
         assertTrue("Frame should not be disposed when script has no terminate",
 232    
                    f.isShowing());
 233    
     }
 234    
 
 235    
     // StepRunner.stop should leave the SUT in its state at the time of stop.
 236  1 
     public void testRunToStep() throws Throwable {
 237  1 
         Script script = new Script(getHierarchy());
 238  1 
         Step one = new DefaultStep("one");
 239  1 
         final Step two = new DefaultStep("two");
 240  1 
         script.addStep(one);
 241  1 
         script.addStep(two);
 242  1 
         final TestStepRunner runner = new TestStepRunner();
 243  1 
         runner.addStepListener(new StepListener() {
 244  5 
             public void stateChanged(StepEvent ev) {
 245  5 
                 if (ev.getSource() == two)
 246  1 
                     runner.stop();
 247    
             }
 248    
         });
 249  1 
         try {
 250  1 
             runner.run(script);
 251    
         }
 252    
         finally {
 253  1 
             runner.realTerminate();
 254    
         }
 255    
     }
 256    
 
 257    
     /** If a nested file does not exist, an exception should be thrown. */
 258  1 
     public void testScriptNotFound() throws Throwable {
 259  1 
         Script script = new Script(getHierarchy());
 260  1 
         Script nested = new Script(getHierarchy());
 261  1 
         nested.setFile(new File("somewhere/relative/file.xml"));
 262  1 
         script.addStep(nested);
 263  1 
         try {
 264  1 
             runner.run(script);
 265  0 
             fail("Exception should have been thrown");
 266    
         }
 267    
         catch(InvalidScriptException ise) {
 268    
         }
 269    
     }
 270    
 
 271    
     private class DefaultStep extends Step {
 272  13 
         public DefaultStep(String desc) {
 273  13 
             super(resolver, desc);
 274    
         }
 275  4 
         public void runStep() throws Throwable { }
 276  0 
         public String getXMLTag() { return ""; }
 277  0 
         public String getUsage() { return ""; }
 278  0 
         public String getDefaultDescription() { return ""; }
 279    
     }
 280    
 
 281    
     private class FailingStep extends DefaultStep {
 282  2 
         public FailingStep(String desc) {
 283  2 
             super(desc);
 284    
         }
 285  2 
         public void runStep() throws Throwable {
 286  2 
             throw new AssertionFailedError(getDescription());
 287    
         }
 288    
     }
 289    
 
 290    
     private class ErrorStep extends DefaultStep {
 291  4 
         public ErrorStep(String desc) {
 292  4 
             super(desc);
 293    
         }
 294  4 
         public void runStep() throws Throwable {
 295  4 
             throw new Error(getDescription());
 296    
         }
 297    
     }
 298    
 
 299    
     private class EDTErrorStep extends DefaultStep {
 300  1 
         public EDTErrorStep() {
 301  1 
             super("EDT error");
 302    
         }
 303  1 
         public void runStep() throws Throwable {
 304  1 
             SwingUtilities.invokeLater(new Runnable() {
 305  1 
                 public void run() {
 306  1 
                     throw new TestEDTError();
 307    
                 }
 308    
             });
 309  1 
             SwingUtilities.invokeAndWait(new Runnable() {
 310  1 
                 public void run() { }
 311    
             });
 312    
         }
 313    
     }
 314    
 
 315    
     private class TestStepRunner extends StepRunner {
 316  0 
         public void terminate() {
 317  0 
             fail("Step runner should not terminate when stopped");
 318    
         }
 319  1 
         public void realTerminate() {
 320  1 
             super.terminate();
 321    
         }
 322    
     }
 323    
 
 324    
     private class TestEDTError extends Error {
 325  1 
         public TestEDTError() { super("Test EDT Error"); }
 326    
     }
 327    
 
 328  0 
     public static void main(String[] args) {
 329  0 
         TestHelper.runTests(args, StepRunnerTest.class);
 330    
     }
 331    
 }
 332    
 
 
CloverReport generated by Clover v1.2.4_02
Sat Oct 8 2005 22:54:29 EDT.		   Open Source License registered to the Abbot Project. This license of Clover is provided to support the development of Abbot only.