How to use addError method of junit.framework.Interface TestListener class

Best junit code snippet using junit.framework.Interface TestListener.addError

Run junit automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

copy
1/*******************************************************************************
2 * Copyright (c) 2000, 2009 IBM Corporation and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 *     IBM Corporation - initial API and implementation
10 *******************************************************************************/
11package org.eclipse.jdt.core.tests.junit.extension;
12
13import junit.framework.Test;
14import junit.framework.TestFailure;
15
16/**
17 * A Listener for test progress
18 */
19public interface TestListener extends junit.framework.TestListener {
20
21    /**
22 	* An error occurred.
23 	*/
24    public void addError(Test test, TestFailure testFailure);
25
26    /**
27 	* A failure occurred.
28 	*/
29    public void addFailure(Test test, TestFailure testFailure);
30}
31
Full Screen
copy
1package edu.cs.hku.testExecution;
2
3import junit.framework.Test;
4import junit.framework.TestListener;
5
6public interface GroupedTestListener extends TestListener{
7	
8	public void addError(Test test, Throwable t, GroupedTestFailure parent);
9}
10
Full Screen
copy
1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 *
17 */
18
19package org.apache.tools.ant.taskdefs.optional.junit;
20
21import java.io.BufferedReader;
22import java.io.ByteArrayOutputStream;
23import java.io.File;
24import java.io.FileInputStream;
25import java.io.FileWriter;
26import java.io.IOException;
27import java.io.OutputStream;
28import java.io.PrintStream;
29import java.io.PrintWriter;
30import java.io.StringReader;
31import java.io.StringWriter;
32import java.lang.reflect.Method;
33import java.util.Enumeration;
34import java.util.Hashtable;
35import java.util.Properties;
36import java.util.StringTokenizer;
37import java.util.Vector;
38import junit.framework.AssertionFailedError;
39import junit.framework.Test;
40import junit.framework.TestFailure;
41import junit.framework.TestListener;
42import junit.framework.TestResult;
43import junit.framework.TestSuite;
44import org.apache.tools.ant.BuildException;
45import org.apache.tools.ant.Project;
46import org.apache.tools.ant.types.Permissions;
47import org.apache.tools.ant.util.StringUtils;
48import org.apache.tools.ant.util.TeeOutputStream;
49
50/**
51 * Simple Testrunner for JUnit that runs all tests of a testsuite.
52 *
53 * <p>This TestRunner expects a name of a TestCase class as its
54 * argument. If this class provides a static suite() method it will be
55 * called and the resulting Test will be run. So, the signature should be
56 * <pre><code>
57 *     public static junit.framework.Test suite()
58 * </code></pre>
59 *
60 * <p> If no such method exists, all public methods starting with
61 * "test" and taking no argument will be run.
62 *
63 * <p> Summary output is generated at the end.
64 *
65 * @since Ant 1.2
66 */
67
68public class JUnitTestRunner implements TestListener, JUnitTaskMirror.JUnitTestRunnerMirror {
69
70    /**
71     * Holds the registered formatters.
72     */
73    private Vector formatters = new Vector();
74
75    /**
76     * Collects TestResults.
77     */
78    private TestResult res;
79
80    /**
81     * Do we filter junit.*.* stack frames out of failure and error exceptions.
82     */
83    private static boolean filtertrace = true;
84
85    /**
86     * Do we send output to System.out/.err in addition to the formatters?
87     */
88    private boolean showOutput = false;
89
90    private boolean outputToFormatters = true;
91
92    /**
93     * The permissions set for the test to run.
94     */
95    private Permissions perm = null;
96
97    private static final String[] DEFAULT_TRACE_FILTERS = new String[] {
98                "junit.framework.TestCase",
99                "junit.framework.TestResult",
100                "junit.framework.TestSuite",
101                "junit.framework.Assert.", // don't filter AssertionFailure
102                "junit.swingui.TestRunner",
103                "junit.awtui.TestRunner",
104                "junit.textui.TestRunner",
105                "java.lang.reflect.Method.invoke(",
106                "sun.reflect.",
107                "org.apache.tools.ant.",
108                // JUnit 4 support:
109                "org.junit.",
110                "junit.framework.JUnit4TestAdapter",
111                // See wrapListener for reason:
112                "Caused by: java.lang.AssertionError",
113                " more",
114        };
115
116
117    /**
118     * Do we stop on errors.
119     */
120    private boolean haltOnError = false;
121
122    /**
123     * Do we stop on test failures.
124     */
125    private boolean haltOnFailure = false;
126
127    /**
128     * Returncode
129     */
130    private int retCode = SUCCESS;
131
132    /**
133     * The TestSuite we are currently running.
134     */
135    private JUnitTest junitTest;
136
137    /** output written during the test */
138    private PrintStream systemError;
139
140    /** Error output during the test */
141    private PrintStream systemOut;
142
143    /** is this runner running in forked mode? */
144    private boolean forked = false;
145
146    /** Running more than one test suite? */
147    private static boolean multipleTests = false;
148
149    /** ClassLoader passed in in non-forked mode. */
150    private ClassLoader loader;
151
152    /** Do we print TestListener events? */
153    private boolean logTestListenerEvents = false;
154
155    /** Turned on if we are using JUnit 4 for this test suite. see #38811 */
156    private boolean junit4;
157
158    /**
159     * The file used to indicate that the build crashed.
160     * File will be empty in case the build did not crash.
161     */
162    private static String crashFile = null;
163
164    /**
165     * Constructor for fork=true or when the user hasn't specified a
166     * classpath.
167     * @param test the test to run.
168     * @param haltOnError whether to stop the run if an error is found.
169     * @param filtertrace whether to filter junit.*.* stack frames out of exceptions
170     * @param haltOnFailure whether to stop the run if failure is found.
171     */
172    public JUnitTestRunner(JUnitTest test, boolean haltOnError,
173                           boolean filtertrace, boolean haltOnFailure) {
174        this(test, haltOnError, filtertrace, haltOnFailure, false);
175    }
176
177    /**
178     * Constructor for fork=true or when the user hasn't specified a
179     * classpath.
180     * @param test the test to run.
181     * @param haltOnError whether to stop the run if an error is found.
182     * @param filtertrace whether to filter junit.*.* stack frames out of exceptions
183     * @param haltOnFailure whether to stop the run if failure is found.
184     * @param showOutput    whether to send output to System.out/.err as well as formatters.
185     */
186    public JUnitTestRunner(JUnitTest test, boolean haltOnError,
187                           boolean filtertrace, boolean haltOnFailure,
188                           boolean showOutput) {
189        this(test, haltOnError, filtertrace, haltOnFailure, showOutput, false);
190    }
191
192    /**
193     * Constructor for fork=true or when the user hasn't specified a
194     * classpath.
195     * @param test the test to run.
196     * @param haltOnError whether to stop the run if an error is found.
197     * @param filtertrace whether to filter junit.*.* stack frames out of exceptions
198     * @param haltOnFailure whether to stop the run if failure is found.
199     * @param showOutput    whether to send output to System.out/.err as well as formatters.
200     * @param logTestListenerEvents whether to print TestListener events.
201     * @since Ant 1.7
202     */
203    public JUnitTestRunner(JUnitTest test, boolean haltOnError,
204                           boolean filtertrace, boolean haltOnFailure,
205                           boolean showOutput, boolean logTestListenerEvents) {
206        this(test, haltOnError, filtertrace, haltOnFailure, showOutput,
207             logTestListenerEvents, null);
208    }
209
210    /**
211     * Constructor to use when the user has specified a classpath.
212     * @param test the test to run.
213     * @param haltOnError whether to stop the run if an error is found.
214     * @param filtertrace whether to filter junit.*.* stack frames out of exceptions
215     * @param haltOnFailure whether to stop the run if failure is found.
216     * @param loader the classloader to use running the test.
217     */
218    public JUnitTestRunner(JUnitTest test, boolean haltOnError,
219                           boolean filtertrace, boolean haltOnFailure,
220                           ClassLoader loader) {
221        this(test, haltOnError, filtertrace, haltOnFailure, false, loader);
222    }
223
224    /**
225     * Constructor to use when the user has specified a classpath.
226     * @param test the test to run.
227     * @param haltOnError whether to stop the run if an error is found.
228     * @param filtertrace whether to filter junit.*.* stack frames out of exceptions
229     * @param haltOnFailure whether to stop the run if failure is found.
230     * @param showOutput    whether to send output to System.out/.err as well as formatters.
231     * @param loader the classloader to use running the test.
232     */
233    public JUnitTestRunner(JUnitTest test, boolean haltOnError,
234                           boolean filtertrace, boolean haltOnFailure,
235                           boolean showOutput, ClassLoader loader) {
236        this(test, haltOnError, filtertrace, haltOnFailure, showOutput,
237             false, loader);
238    }
239
240    /**
241     * Constructor to use when the user has specified a classpath.
242     * @param test the test to run.
243     * @param haltOnError whether to stop the run if an error is found.
244     * @param filtertrace whether to filter junit.*.* stack frames out of exceptions
245     * @param haltOnFailure whether to stop the run if failure is found.
246     * @param showOutput    whether to send output to System.out/.err as well as formatters.
247     * @param logTestListenerEvents whether to print TestListener events.
248     * @param loader the classloader to use running the test.
249     * @since Ant 1.7
250     */
251    public JUnitTestRunner(JUnitTest test, boolean haltOnError,
252                           boolean filtertrace, boolean haltOnFailure,
253                           boolean showOutput, boolean logTestListenerEvents,
254                           ClassLoader loader) {
255        JUnitTestRunner.filtertrace = filtertrace;
256        this.junitTest = test;
257        this.haltOnError = haltOnError;
258        this.haltOnFailure = haltOnFailure;
259        this.showOutput = showOutput;
260        this.logTestListenerEvents = logTestListenerEvents;
261        this.loader = loader;
262    }
263
264    private PrintStream savedOut = null;
265
266    /**
267     * Run the test.
268     */
269    public void run() {
270        res = new TestResult();
271        res.addListener(wrapListener(this));
272        for (int i = 0; i < formatters.size(); i++) {
273            res.addListener(wrapListener((TestListener) formatters.elementAt(i)));
274        }
275
276        ByteArrayOutputStream errStrm = new ByteArrayOutputStream();
277        systemError = new PrintStream(errStrm);
278
279        ByteArrayOutputStream outStrm = new ByteArrayOutputStream();
280        systemOut = new PrintStream(outStrm);
281
282        PrintStream savedErr = null;
283
284        if (forked) {
285            if (!outputToFormatters) {
286                if (!showOutput) {
287                    savedOut = System.out;
288                    savedErr = System.err;
289                    System.setOut(
290                        new PrintStream(
291                            new OutputStream() {
292                                public void write(int b) {
293                                }
294                            }));
295                    System.setErr(
296                        new PrintStream(
297                            new OutputStream() {
298                                public void write(int b) {
299                                }
300                            }));
301                }
302            } else {
303                savedOut = System.out;
304                savedErr = System.err;
305                if (!showOutput) {
306                    System.setOut(systemOut);
307                    System.setErr(systemError);
308                } else {
309                    System.setOut(new PrintStream(
310                                      new TeeOutputStream(savedOut, systemOut)
311                                      )
312                                  );
313                    System.setErr(new PrintStream(
314                                      new TeeOutputStream(savedErr,
315                                                          systemError)
316                                      )
317                                  );
318                }
319                perm = null;
320            }
321        } else {
322            if (perm != null) {
323                perm.setSecurityManager();
324            }
325        }
326
327        Test suite = null;
328        Throwable exception = null;
329        boolean startTestSuiteSuccess = false;
330
331        try {
332
333            try {
334                Class testClass = null;
335                if (loader == null) {
336                    testClass = Class.forName(junitTest.getName());
337                } else {
338                    testClass = Class.forName(junitTest.getName(), true,
339                                              loader);
340                }
341
342                // check for a static suite method first, even when using
343                // JUnit 4
344                Method suiteMethod = null;
345                try {
346                    // check if there is a suite method
347                    suiteMethod = testClass.getMethod("suite", new Class[0]);
348                } catch (NoSuchMethodException e) {
349                    // no appropriate suite method found. We don't report any
350                    // error here since it might be perfectly normal.
351                }
352
353                if (suiteMethod != null) {
354                    // if there is a suite method available, then try
355                    // to extract the suite from it. If there is an error
356                    // here it will be caught below and reported.
357                    suite = (Test) suiteMethod.invoke(null, new Class[0]);
358
359                } else {
360                    Class junit4TestAdapterClass = null;
361
362                    // Check for JDK 5 first. Will *not* help on JDK 1.4
363                    // if only junit-4.0.jar in CP because in that case
364                    // linkage of whole task will already have failed! But
365                    // will help if CP has junit-3.8.2.jar:junit-4.0.jar.
366
367                    // In that case first C.fN will fail with CNFE and we
368                    // will avoid UnsupportedClassVersionError.
369
370                    try {
371                        Class.forName("java.lang.annotation.Annotation");
372                        if (loader == null) {
373                            junit4TestAdapterClass =
374                                Class.forName("junit.framework.JUnit4TestAdapter");
375                        } else {
376                            junit4TestAdapterClass =
377                                Class.forName("junit.framework.JUnit4TestAdapter",
378                                              true, loader);
379                        }
380                    } catch (ClassNotFoundException e) {
381                        // OK, fall back to JUnit 3.
382                    }
383                    junit4 = junit4TestAdapterClass != null;
384
385                    if (junit4) {
386                        // Let's use it!
387                        suite =
388                            (Test) junit4TestAdapterClass
389                            .getConstructor(new Class[] {Class.class}).
390                            newInstance(new Object[] {testClass});
391                    } else {
392                        // Use JUnit 3.
393
394                        // try to extract a test suite automatically this
395                        // will generate warnings if the class is no
396                        // suitable Test
397                        suite = new TestSuite(testClass);
398                    }
399
400                }
401
402            } catch (Throwable e) {
403                retCode = ERRORS;
404                exception = e;
405            }
406
407            long start = System.currentTimeMillis();
408
409            fireStartTestSuite();
410            startTestSuiteSuccess = true;
411            if (exception != null) { // had an exception constructing suite
412                for (int i = 0; i < formatters.size(); i++) {
413                    ((TestListener) formatters.elementAt(i))
414                        .addError(null, exception);
415                }
416                junitTest.setCounts(1, 0, 1);
417                junitTest.setRunTime(0);
418            } else {
419                try {
420                    logTestListenerEvent("tests to run: " + suite.countTestCases());
421                    suite.run(res);
422                } finally {
423                    if (junit4) {
424                        int[] cnts = findJUnit4FailureErrorCount(res);
425                        junitTest.setCounts(res.runCount(), cnts[0], cnts[1]);
426                    } else {
427                        junitTest.setCounts(res.runCount(), res.failureCount(),
428                                res.errorCount());
429                    }
430                    junitTest.setRunTime(System.currentTimeMillis() - start);
431                }
432            }
433        } finally {
434            if (perm != null) {
435                perm.restoreSecurityManager();
436            }
437            if (savedOut != null) {
438                System.setOut(savedOut);
439            }
440            if (savedErr != null) {
441                System.setErr(savedErr);
442            }
443
444            systemError.close();
445            systemError = null;
446            systemOut.close();
447            systemOut = null;
448            if (startTestSuiteSuccess) {
449                sendOutAndErr(new String(outStrm.toByteArray()),
450                              new String(errStrm.toByteArray()));
451            }
452        }
453        fireEndTestSuite();
454
455        if (retCode != SUCCESS || res.errorCount() != 0) {
456            retCode = ERRORS;
457        } else if (res.failureCount() != 0) {
458            retCode = FAILURES;
459        }
460    }
461
462    /**
463     * Returns what System.exit() would return in the standalone version.
464     *
465     * @return 2 if errors occurred, 1 if tests failed else 0.
466     */
467    public int getRetCode() {
468        return retCode;
469    }
470
471    /**
472     * Interface TestListener.
473     *
474     * <p>A new Test is started.
475     * @param t the test.
476     */
477    public void startTest(Test t) {
478        String testName = JUnitVersionHelper.getTestCaseName(t);
479        logTestListenerEvent("startTest(" + testName + ")");
480    }
481
482    /**
483     * Interface TestListener.
484     *
485     * <p>A Test is finished.
486     * @param test the test.
487     */
488    public void endTest(Test test) {
489        String testName = JUnitVersionHelper.getTestCaseName(test);
490        logTestListenerEvent("endTest(" + testName + ")");
491    }
492
493    private void logTestListenerEvent(String msg) {
494        PrintStream out = savedOut != null ? savedOut : System.out;
495        if (logTestListenerEvents) {
496            out.flush();
497            out.println(JUnitTask.TESTLISTENER_PREFIX + msg);
498            out.flush();
499        }
500    }
501
502    /**
503     * Interface TestListener for JUnit &lt;= 3.4.
504     *
505     * <p>A Test failed.
506     * @param test the test.
507     * @param t    the exception thrown by the test.
508     */
509    public void addFailure(Test test, Throwable t) {
510        String testName = JUnitVersionHelper.getTestCaseName(test);
511        logTestListenerEvent("addFailure(" + testName + ", " + t.getMessage() + ")");
512        if (haltOnFailure) {
513            res.stop();
514        }
515    }
516
517    /**
518     * Interface TestListener for JUnit &gt; 3.4.
519     *
520     * <p>A Test failed.
521     * @param test the test.
522     * @param t    the assertion thrown by the test.
523     */
524    public void addFailure(Test test, AssertionFailedError t) {
525        addFailure(test, (Throwable) t);
526    }
527
528    /**
529     * Interface TestListener.
530     *
531     * <p>An error occurred while running the test.
532     * @param test the test.
533     * @param t    the error thrown by the test.
534     */
535    public void addError(Test test, Throwable t) {
536        String testName = JUnitVersionHelper.getTestCaseName(test);
537        logTestListenerEvent("addError(" + testName + ", " + t.getMessage() + ")");
538        if (haltOnError) {
539            res.stop();
540        }
541    }
542
543    /**
544     * Permissions for the test run.
545     * @since Ant 1.6
546     * @param permissions the permissions to use.
547     */
548    public void setPermissions(Permissions permissions) {
549        perm = permissions;
550    }
551
552    /**
553     * Handle a string destined for standard output.
554     * @param output the string to output
555     */
556    public void handleOutput(String output) {
557        if (!logTestListenerEvents && output.startsWith(JUnitTask.TESTLISTENER_PREFIX)) {
558            // ignore
559        } else if (systemOut != null) {
560            systemOut.print(output);
561        }
562    }
563
564    /**
565     * Handle input.
566     * @param buffer not used.
567     * @param offset not used.
568     * @param length not used.
569     * @return -1 always.
570     * @throws IOException never.
571     * @see org.apache.tools.ant.Task#handleInput(byte[], int, int)
572     *
573     * @since Ant 1.6
574     */
575    public int handleInput(byte[] buffer, int offset, int length)
576        throws IOException {
577        return -1;
578    }
579
580    /** {@inheritDoc}. */
581    public void handleErrorOutput(String output) {
582        if (systemError != null) {
583            systemError.print(output);
584        }
585    }
586
587    /** {@inheritDoc}. */
588    public void handleFlush(String output) {
589        if (systemOut != null) {
590            systemOut.print(output);
591        }
592    }
593
594    /** {@inheritDoc}. */
595    public void handleErrorFlush(String output) {
596        if (systemError != null) {
597            systemError.print(output);
598        }
599    }
600
601    private void sendOutAndErr(String out, String err) {
602        for (int i = 0; i < formatters.size(); i++) {
603            JUnitResultFormatter formatter =
604                ((JUnitResultFormatter) formatters.elementAt(i));
605
606            formatter.setSystemOutput(out);
607            formatter.setSystemError(err);
608        }
609    }
610
611    private void fireStartTestSuite() {
612        for (int i = 0; i < formatters.size(); i++) {
613            ((JUnitResultFormatter) formatters.elementAt(i))
614                .startTestSuite(junitTest);
615        }
616    }
617
618    private void fireEndTestSuite() {
619        for (int i = 0; i < formatters.size(); i++) {
620            ((JUnitResultFormatter) formatters.elementAt(i))
621                .endTestSuite(junitTest);
622        }
623    }
624
625    /**
626     * Add a formatter.
627     * @param f the formatter to add.
628     */
629    public void addFormatter(JUnitResultFormatter f) {
630        formatters.addElement(f);
631    }
632
633    /** {@inheritDoc}. */
634    public void addFormatter(JUnitTaskMirror.JUnitResultFormatterMirror f) {
635        formatters.addElement((JUnitResultFormatter) f);
636    }
637
638    /**
639     * Entry point for standalone (forked) mode.
640     *
641     * Parameters: testcaseclassname plus parameters in the format
642     * key=value, none of which is required.
643     *
644     * <table cols="4" border="1">
645     * <tr><th>key</th><th>description</th><th>default value</th></tr>
646     *
647     * <tr><td>haltOnError</td><td>halt test on
648     * errors?</td><td>false</td></tr>
649     *
650     * <tr><td>haltOnFailure</td><td>halt test on
651     * failures?</td><td>false</td></tr>
652     *
653     * <tr><td>formatter</td><td>A JUnitResultFormatter given as
654     * classname,filename. If filename is ommitted, System.out is
655     * assumed.</td><td>none</td></tr>
656     *
657     * <tr><td>showoutput</td><td>send output to System.err/.out as
658     * well as to the formatters?</td><td>false</td></tr>
659     *
660     * <tr><td>logtestlistenerevents</td><td>log TestListener events to
661     * System.out.</td><td>false</td></tr>
662     *
663     * </table>
664     * @param args the command line arguments.
665     * @throws IOException on error.
666     */
667    public static void main(String[] args) throws IOException {
668        boolean haltError = false;
669        boolean haltFail = false;
670        boolean stackfilter = true;
671        Properties props = new Properties();
672        boolean showOut = false;
673        boolean outputToFormat = true;
674        boolean logTestListenerEvents = false;
675
676
677        if (args.length == 0) {
678            System.err.println("required argument TestClassName missing");
679            System.exit(ERRORS);
680        }
681
682        if (args[0].startsWith(Constants.TESTSFILE)) {
683            multipleTests = true;
684            args[0] = args[0].substring(Constants.TESTSFILE.length());
685        }
686
687        for (int i = 1; i < args.length; i++) {
688            if (args[i].startsWith(Constants.HALT_ON_ERROR)) {
689                haltError = Project.toBoolean(args[i].substring(Constants.HALT_ON_ERROR.length()));
690            } else if (args[i].startsWith(Constants.HALT_ON_FAILURE)) {
691                haltFail = Project.toBoolean(args[i].substring(Constants.HALT_ON_FAILURE.length()));
692            } else if (args[i].startsWith(Constants.FILTERTRACE)) {
693                stackfilter = Project.toBoolean(args[i].substring(Constants.FILTERTRACE.length()));
694            } else if (args[i].startsWith(Constants.CRASHFILE)) {
695                crashFile = args[i].substring(Constants.CRASHFILE.length());
696                registerTestCase(Constants.BEFORE_FIRST_TEST);
697            } else if (args[i].startsWith(Constants.FORMATTER)) {
698                try {
699                    createAndStoreFormatter(args[i].substring(Constants.FORMATTER.length()));
700                } catch (BuildException be) {
701                    System.err.println(be.getMessage());
702                    System.exit(ERRORS);
703                }
704            } else if (args[i].startsWith(Constants.PROPSFILE)) {
705                FileInputStream in = new FileInputStream(args[i]
706                                                         .substring(Constants.PROPSFILE.length()));
707                props.load(in);
708                in.close();
709            } else if (args[i].startsWith(Constants.SHOWOUTPUT)) {
710                showOut = Project.toBoolean(args[i].substring(Constants.SHOWOUTPUT.length()));
711            } else if (args[i].startsWith(Constants.LOGTESTLISTENEREVENTS)) {
712                logTestListenerEvents = Project.toBoolean(
713                    args[i].substring(Constants.LOGTESTLISTENEREVENTS.length()));
714            } else if (args[i].startsWith(Constants.OUTPUT_TO_FORMATTERS)) {
715                outputToFormat = Project.toBoolean(
716                    args[i].substring(Constants.OUTPUT_TO_FORMATTERS.length()));
717            }
718        }
719
720        // Add/overlay system properties on the properties from the Ant project
721        Hashtable p = System.getProperties();
722        for (Enumeration e = p.keys(); e.hasMoreElements();) {
723            Object key = e.nextElement();
724            props.put(key, p.get(key));
725        }
726
727        int returnCode = SUCCESS;
728        if (multipleTests) {
729            try {
730                java.io.BufferedReader reader =
731                    new java.io.BufferedReader(new java.io.FileReader(args[0]));
732                String testCaseName;
733                int code = 0;
734                boolean errorOccurred = false;
735                boolean failureOccurred = false;
736                String line = null;
737                while ((line = reader.readLine()) != null) {
738                    StringTokenizer st = new StringTokenizer(line, ",");
739                    testCaseName = st.nextToken();
740                    JUnitTest t = new JUnitTest(testCaseName);
741                    t.setTodir(new File(st.nextToken()));
742                    t.setOutfile(st.nextToken());
743                    code = launch(t, haltError, stackfilter, haltFail,
744                                  showOut, outputToFormat,
745                                  logTestListenerEvents, props);
746                    errorOccurred = (code == ERRORS);
747                    failureOccurred = (code != SUCCESS);
748                    if (errorOccurred || failureOccurred) {
749                        if ((errorOccurred && haltError)
750                            || (failureOccurred && haltFail)) {
751                            registerNonCrash();
752                            System.exit(code);
753                        } else {
754                            if (code > returnCode) {
755                                returnCode = code;
756                            }
757                            System.out.println("TEST " + t.getName()
758                                               + " FAILED");
759                        }
760                    }
761                }
762            } catch (IOException e) {
763                e.printStackTrace();
764            }
765        } else {
766            returnCode = launch(new JUnitTest(args[0]), haltError,
767                                stackfilter, haltFail,
768                                showOut, outputToFormat,
769                                logTestListenerEvents, props);
770        }
771
772        registerNonCrash();
773        System.exit(returnCode);
774    }
775
776    private static Vector fromCmdLine = new Vector();
777
778    private static void transferFormatters(JUnitTestRunner runner,
779                                           JUnitTest test) {
780        runner.addFormatter(new JUnitResultFormatter() {
781
782            public void startTestSuite(JUnitTest suite) throws BuildException {
783            }
784
785            public void endTestSuite(JUnitTest suite) throws BuildException {
786            }
787
788            public void setOutput(OutputStream out) {
789            }
790
791            public void setSystemOutput(String out) {
792            }
793
794            public void setSystemError(String err) {
795            }
796
797            public void addError(Test arg0, Throwable arg1) {
798            }
799
800            public void addFailure(Test arg0, AssertionFailedError arg1) {
801            }
802
803            public void endTest(Test arg0) {
804            }
805
806            public void startTest(Test arg0) {
807                registerTestCase(JUnitVersionHelper.getTestCaseName(arg0));
808            }
809        });
810        for (int i = 0; i < fromCmdLine.size(); i++) {
811            FormatterElement fe = (FormatterElement) fromCmdLine.elementAt(i);
812            if (multipleTests && fe.getUseFile()) {
813                File destFile =
814                    new File(test.getTodir(),
815                             test.getOutfile() + fe.getExtension());
816                fe.setOutfile(destFile);
817            }
818            runner.addFormatter((JUnitResultFormatter) fe.createFormatter());
819        }
820    }
821
822    /**
823     * Line format is: formatter=<classname>(,<pathname>)?
824     */
825    private static void createAndStoreFormatter(String line)
826        throws BuildException {
827        FormatterElement fe = new FormatterElement();
828        int pos = line.indexOf(',');
829        if (pos == -1) {
830            fe.setClassname(line);
831            fe.setUseFile(false);
832        } else {
833            fe.setClassname(line.substring(0, pos));
834            fe.setUseFile(true);
835            if (!multipleTests) {
836                fe.setOutfile(new File(line.substring(pos + 1)));
837            } else {
838                int fName = line.indexOf(IGNORED_FILE_NAME);
839                if (fName > -1) {
840                    fe.setExtension(line
841                                    .substring(fName
842                                               + IGNORED_FILE_NAME.length()));
843                }
844            }
845        }
846        fromCmdLine.addElement(fe);
847    }
848
849    /**
850     * Returns a filtered stack trace.
851     * This is ripped out of junit.runner.BaseTestRunner.
852     * @param t the exception to filter.
853     * @return the filtered stack trace.
854     */
855    public static String getFilteredTrace(Throwable t) {
856        String trace = StringUtils.getStackTrace(t);
857        return JUnitTestRunner.filterStack(trace);
858    }
859
860    /**
861     * Filters stack frames from internal JUnit and Ant classes
862     * @param stack the stack trace to filter.
863     * @return the filtered stack.
864     */
865    public static String filterStack(String stack) {
866        if (!filtertrace) {
867            return stack;
868        }
869        StringWriter sw = new StringWriter();
870        PrintWriter pw = new PrintWriter(sw);
871        StringReader sr = new StringReader(stack);
872        BufferedReader br = new BufferedReader(sr);
873
874        String line;
875        try {
876            while ((line = br.readLine()) != null) {
877                if (!filterLine(line)) {
878                    pw.println(line);
879                }
880            }
881        } catch (Exception e) {
882            return stack; // return the stack unfiltered
883        }
884        return sw.toString();
885    }
886
887    private static boolean filterLine(String line) {
888        for (int i = 0; i < DEFAULT_TRACE_FILTERS.length; i++) {
889            if (line.indexOf(DEFAULT_TRACE_FILTERS[i]) != -1) {
890                return true;
891            }
892        }
893        return false;
894    }
895
896    /**
897     * @since Ant 1.6.2
898     */
899    private static int launch(JUnitTest t, boolean haltError,
900                              boolean stackfilter, boolean haltFail,
901                              boolean showOut, boolean outputToFormat,
902                              boolean logTestListenerEvents,
903                              Properties props) {
904        t.setProperties(props);
905        JUnitTestRunner runner =
906            new JUnitTestRunner(t, haltError, stackfilter, haltFail, showOut,
907                                logTestListenerEvents, null);
908        runner.forked = true;
909        runner.outputToFormatters = outputToFormat;
910        transferFormatters(runner, t);
911
912        runner.run();
913        return runner.getRetCode();
914     }
915
916    /**
917     * @since Ant 1.7
918     */
919    private static void registerNonCrash()
920            throws IOException {
921        if (crashFile != null) {
922            FileWriter out = null;
923            try {
924                out = new FileWriter(crashFile);
925                out.write(Constants.TERMINATED_SUCCESSFULLY + "\n");
926                out.flush();
927            } finally {
928                if (out != null) {
929                    out.close();
930                }
931            }
932        }
933    }
934
935    private static void registerTestCase(String testCase) {
936        if (crashFile != null) {
937            try {
938                FileWriter out = null;
939                try {
940                    out = new FileWriter(crashFile);
941                    out.write(testCase + "\n");
942                    out.flush();
943                } finally {
944                    if (out != null) {
945                        out.close();
946                    }
947                }
948            } catch (IOException e) {
949                // ignored.
950            }
951        }
952    }
953
954    /**
955     * Modifies a TestListener when running JUnit 4: treats AssertionFailedError
956     * as a failure not an error.
957     *
958     * @since Ant 1.7
959     */
960    private TestListener wrapListener(final TestListener testListener) {
961        return new TestListener() {
962            public void addError(Test test, Throwable t) {
963                if (junit4 && t instanceof AssertionFailedError) {
964                    // JUnit 4 does not distinguish between errors and failures
965                    // even in the JUnit 3 adapter.
966                    // So we need to help it a bit to retain compatibility for JUnit 3 tests.
967                    testListener.addFailure(test, (AssertionFailedError) t);
968                } else if (junit4 && t.getClass().getName().equals("java.lang.AssertionError")) {
969                    // Not strictly necessary but probably desirable.
970                    // JUnit 4-specific test GUIs will show just "failures".
971                    // But Ant's output shows "failures" vs. "errors".
972                    // We would prefer to show "failure" for things that logically are.
973                    try {
974                        String msg = t.getMessage();
975                        AssertionFailedError failure = msg != null
976                            ? new AssertionFailedError(msg) : new AssertionFailedError();
977                        // To compile on pre-JDK 4 (even though this should always succeed):
978                        Method initCause = Throwable.class.getMethod(
979                            "initCause", new Class[] {Throwable.class});
980                        initCause.invoke(failure, new Object[] {t});
981                        testListener.addFailure(test, failure);
982                    } catch (Exception e) {
983                        // Rats.
984                        e.printStackTrace(); // should not happen
985                        testListener.addError(test, t);
986                    }
987                } else {
988                    testListener.addError(test, t);
989                }
990            }
991            public void addFailure(Test test, AssertionFailedError t) {
992                testListener.addFailure(test, t);
993            }
994            public void addFailure(Test test, Throwable t) { // pre-3.4
995                if (t instanceof AssertionFailedError) {
996                    testListener.addFailure(test, (AssertionFailedError) t);
997                } else {
998                    testListener.addError(test, t);
999                }
1000            }
1001            public void endTest(Test test) {
1002                testListener.endTest(test);
1003            }
1004            public void startTest(Test test) {
1005                testListener.startTest(test);
1006            }
1007        };
1008    }
1009
1010    /**
1011     * Use instead of TestResult.get{Failure,Error}Count on JUnit 4,
1012     * since the adapter claims that all failures are errors.
1013     * @since Ant 1.7
1014     */
1015    private int[] findJUnit4FailureErrorCount(TestResult res) {
1016        int failures = 0;
1017        int errors = 0;
1018        Enumeration e = res.failures();
1019        while (e.hasMoreElements()) {
1020            e.nextElement();
1021            failures++;
1022        }
1023        e = res.errors();
1024        while (e.hasMoreElements()) {
1025            Throwable t = ((TestFailure) e.nextElement()).thrownException();
1026            if (t instanceof AssertionFailedError
1027                || t.getClass().getName().equals("java.lang.AssertionError")) {
1028                failures++;
1029            } else {
1030                errors++;
1031            }
1032        }
1033        return new int[] {failures, errors};
1034    }
1035
1036} // JUnitTestRunner
1037
Full Screen

Accelerate Your Automation Test Cycles With LambdaTest

Leverage LambdaTest’s cloud-based platform to execute your automation tests in parallel and trim down your test execution time significantly. Your first 100 automation testing minutes are on us.

Try LambdaTest

Most used method in Interface-TestListener

Trigger addError code on LambdaTest Cloud Grid

Execute automation tests with addError on a cloud-based Grid of 3000+ real browsers and operating systems for both web and mobile applications.

Test now for Free
LambdaTestX

We use cookies to give you the best experience. Cookies help to provide a more personalized experience and relevant advertising for you, and web analytics for us. Learn More in our Cookies policy, Privacy & Terms of service

Allow Cookie
Sarah

I hope you find the best code examples for your project.

If you want to accelerate automated browser testing, try LambdaTest. Your first 100 automation testing minutes are FREE.

Sarah Elson (Product & Growth Lead)