@Override public Object start(final IApplicationContext context) throws Exception { final String[] cmdArguments = (String[]) context.getArguments().get(IApplicationContext.APPLICATION_ARGS); Map<String, String> args = null; try { args = processArgs(cmdArguments); } catch (final ArgumentException e) { System.err.println(e.getMessage()); System.err.println(usage()); return -1; } JUnitCore junit = new JUnitCore(); junit.addListener(new MyTextListener()); if (args.containsKey(ARG_XML_OUT)) { final File xmlResultFile = new File(args.get(ARG_XML_OUT)); JUnitXMLRunListener listener = new JUnitXMLRunListener(xmlResultFile); junit.addListener(listener); } logger.info("Starting regression test"); logger.info("Platform default encoding: " + Charset.defaultCharset()); logger.info("Common version: " + getBundleVersion(ProductConstants.PRODUCT_ID_COMMON)); logger.info("Designer version: " + getBundleVersion(ProductConstants.PRODUCT_ID_DESIGNER)); logger.info("Titan regression test version: " + getBundleVersion(REGRESSION_TEST_ID)); Result result = junit.run(MainTestSuite.class); printResult(result); return IApplication.EXIT_OK; }
private String[] runTests(Class<?>... classes) { JUnitCore core = new JUnitCore(); StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); core.addListener(new JUnit4ProgressRunListener(new SimpleMessageSenderFactory(pw))); core.run(classes); return sw.toString().split("\n"); }
public final void run() { final JUnitCore jUnitCore = new JUnitCore(); jUnitCore.addListener(new JUnitTestListener()); jUnitCore.run(TestContexts.class); jUnitCore.run(NextConceptTest.class); // jUnitCore.run(NextImplicationTest.class); // jUnitCore.run(NextClosureTest.class); }
@Override public void setUp() { runner = new JUnitCore(); results = new ByteArrayOutputStream(); PrintStream writer = new PrintStream(results); listener = new TextListener(writer); runner.addListener(listener); }
@Test public void runTestAndVerifyResult() { EventCollector collector = new EventCollector(); JUnitCore core = new JUnitCore(); core.addListener(collector); core.run(classUnderTest); assertThat(collector, matcher); }
@Override public Object[] query() throws Exception { Class<?> klass = getClass().getClassLoader().loadClass(args[0]); JUnitCore core = new JUnitCore(); FitSuiteRunListener listener = new FitSuiteRunListener(); core.addListener(listener); core.run(klass); return listener.getResults().toArray(); }
/** * Runs the test classes given in {@param classes}. * * @returns Zero if all tests pass, non-zero otherwise. */ public static int run(Class[] classes, RunListener listener) { JUnitCore junitCore = new JUnitCore(); junitCore.addListener(listener); boolean hasError = false; for (@AutoreleasePool Class c : classes) { Result result = junitCore.run(c); hasError = hasError || !result.wasSuccessful(); } return hasError ? 1 : 0; }
public static void runInMain(Class<?> testClass, String[] args) throws InitializationError, NoTestsRemainException { JUnitCore core = new JUnitCore(); core.addListener(new TextListener(System.out)); SLTestRunner suite = new SLTestRunner(testClass); if (args.length > 0) { suite.filter(new NameFilter(args[0])); } Result r = core.run(suite); if (!r.wasSuccessful()) { System.exit(1); } }
private RunStatistics runClasses( DefaultReporterFactory reporterManagerFactory, org.junit.runner.notification.RunListener demultiplexingRunListener, Class<?>... classes) throws TestSetFailedException { JUnitCore jUnitCore = new JUnitCore(); jUnitCore.addListener(demultiplexingRunListener); Computer computer = new Computer(); jUnitCore.run(computer, classes); return reporterManagerFactory.getGlobalRunStatistics(); }
/** * Constructor. * * @param testRunName Name of the test run the execute * @param configPath Path to the configuration file * @param listener Optional, a listener for the JUnit Events. If not set the default listener * com.day.qa.test.TestRunListener will be used. Can be used by customer to create their own * reports. * @throws Exception if an error occured during execution of the class */ TestRunner(String testRunName, String configPath, RunListener listener) throws Exception { // load the config file config = new TestRunnerConfig(configPath); // instantiate the JUnitCore runner jUnitRunner = new JUnitCore(); // add the listener jUnitRunner.addListener(listener); // run the tests executeTestRun(testRunName); }
@Test public void failedAssumptionsCanBeDetectedByListeners() { assumptionFailures = 0; JUnitCore core = new JUnitCore(); core.addListener( new RunListener() { @Override public void testAssumptionFailure(Failure failure) { assumptionFailures++; } }); core.run(HasFailingAssumption.class); assertThat(assumptionFailures, is(1)); }
private RunStatistics runClasses(Class<?>... classes) throws TestSetFailedException { HashMap<String, TestSet> classMethodCounts = new HashMap<String, TestSet>(); final DefaultReporterFactory reporterManagerFactory = createReporterFactory(); org.junit.runner.notification.RunListener demultiplexingRunListener = createRunListener(reporterManagerFactory, classMethodCounts); JUnitCore jUnitCore = new JUnitCore(); jUnitCore.addListener(demultiplexingRunListener); Computer computer = new Computer(); jUnitCore.run(computer, classes); reporterManagerFactory.close(); return reporterManagerFactory.getGlobalRunStatistics(); }
@Override protected int doWork() throws Exception { // this is called from the command line, so we should set to use the distributed cluster IntegrationTestingUtility.setUseDistributedCluster(conf); Class<?>[] classes = findIntegrationTestClasses(); LOG.info("Found " + classes.length + " integration tests to run:"); for (Class<?> aClass : classes) { LOG.info(" " + aClass); } JUnitCore junit = new JUnitCore(); junit.addListener(new TextListener(System.out)); Result result = junit.run(classes); return result.wasSuccessful() ? 0 : 1; }
/** * @param system * @args args from main() */ private Result runMain(JUnitSystem system, String... args) { system.out().println("JUnit version " + Version.id()); List<Class<?>> classes = new ArrayList<Class<?>>(); List<Failure> missingClasses = new ArrayList<Failure>(); for (String each : args) try { classes.add(Class.forName(each)); } catch (ClassNotFoundException e) { system.out().println("Could not find class: " + each); Description description = Description.createSuiteDescription(each); Failure failure = new Failure(description, e); missingClasses.add(failure); } RunListener listener = new TextListener(system); addListener(listener); Result result = run(classes.toArray(new Class[0])); for (Failure each : missingClasses) result.getFailures().add(each); return result; }
public boolean run() throws IOException { try { m_dir = "testout/junit-" + m_timestamp + "/" + m_testClazz.getCanonicalName() + "/"; new File(m_dir).mkdirs(); // redirect std out/err to files m_out.addOutputStream(new File(m_dir + "fulloutput.txt")); System.setOut(new PrintStream(m_out, true)); System.setErr(new PrintStream(m_out, true)); JUnitCore junit = new JUnitCore(); junit.addListener(this); Result r = junit.run(m_testClazz); STDOUT.printf("RESULTS: %d/%d\n", r.getRunCount() - r.getFailureCount(), r.getRunCount()); return true; } catch (Exception e) { return false; } finally { m_out.flush(); System.setOut(STDOUT); System.setErr(STDERR); m_out.close(); } }
@Before public void setUp() { jUnitCore.addListener(testListener); }
public static int[] replayMetaProgramWith(Class<?> TEST_CLASS) throws Exception { System.out.println("******************" + TEST_CLASS.getName() + "******************"); boolean debug = false; JUnitCore core = new JUnitCore(); // output folder File fail = new File("results/fail.replay/" + TEST_CLASS.getName().replace(".", "/")); fail.mkdirs(); File success = new File("results/success.replay/" + TEST_CLASS.getName().replace(".", "/")); success.mkdirs(); String path = "results/fail/" + TEST_CLASS.getName().replace(".", "/"); File source = new File(path); File[] mutants; if (source.exists() && source.isDirectory()) { mutants = source.listFiles(); } else { throw new Exception( "The directory fail or success dosen't exist, or is not a directory, please execute MutantSearchSpaceExplorator.runMetaProgramWith(Class<?> TEST_CLASS) first."); } // we first run the test suite once to load all classes and their static // fields // this registers only the executed ifs, so indirectly // it collects a kind of trace Result result = core.run(TEST_CLASS); if (debug) { core.addListener(new TextListener(System.out)); } List<Selector> selectors = Selector.getAllSelectors(); // if (selectors.isEmpty()) // // There's no hot spot in program. Add one to run it at least once // selectors = ImmutableList.of(Selector.of(0, "n/a")); List<String> successes = Lists.newArrayList(); List<String> failures = Lists.newArrayList(); Multimap<Integer, String> failures2 = Multimaps.newListMultimap(Maps.newHashMap(), Lists::newArrayList); String[] strOptions = new String[selectors.size()]; // Execute the test for each hot spot permutation // for (int[] options : // permutations(selectors.stream().map(Selector::getOptionCount).collect(Collectors.toList()))) // { int nattempts = 0; for (int mut = 0; mut < mutants.length; mut++) { Config conf = Config.getInitInstance(); Map<String, Integer> mapedConf = conf.getConfig(mutants[mut].getPath()).get(selectors.get(0).getLocationClass().getName()); Set<String> cles = mapedConf.keySet(); int[] options = new int[selectors.size()]; int sel = 0; for (String cle : cles) { Selector.getSelectorByName(cle).choose(mapedConf.get(cle)); strOptions[sel] = Selector.getSelectorByName(cle).getChosenOptionDescription(); for (int o = 0; o < Selector.getSelectorByName(cle).getOptionCount(); o++) { boolean value = (o == mapedConf.get(cle)) ? true : false; conf.write( Selector.getSelectorByName(cle).getLocationClass().getName() + ":" + Selector.getSelectorByName(cle).getId() + ":" + Selector.getSelectorByName(cle).getOption()[o] + ":" + value); } sel++; } if (debug) System.out.println("Checking options: " + Arrays.toString(options)); result = core.run(TEST_CLASS); if (result.wasSuccessful()) { successes.add( " Worked !!! -> " + Arrays.toString(options) + " / " + Arrays.toString(strOptions)); // On essaye avec renameTo File dest = new File(success.getPath() + "/" + mutants[mut].getName()); new File("config.txt").renameTo(dest); } else { String txt = String.format( "%s / %s -> It has %s failures out of %s runs in %s ms", Arrays.toString(options), Arrays.toString(strOptions), result.getFailureCount(), result.getRunCount(), result.getRunTime()); String txt_trace = String.format("%s", Arrays.toString(strOptions)); failures.add(txt); failures2.put(result.getFailureCount(), txt); System.out.println(result.getFailures().get(0).getException()); File dest = new File(fail.getPath() + "/" + mutants[mut].getName()); new File("config.txt").renameTo(dest); } } System.out.println("killed " + failures.size()); System.out.println("alive " + successes.size()); Selector.reset(); int[] val = {failures.size(), successes.size()}; return val; // Show result summary // Sets.newHashSet(failures2.keys()).forEach(k -> { // System.out.println(String.format("\n-- Cases with %s", k)); // Collection<String> texts = failures2.get(k); // if (k <= 2 || texts.size() < 10) // texts.forEach(System.out::println); // else // System.out.println("There are " + texts.size()); // }); // failures.forEach(System.out::println); // System.out.println(); // // if (successes.isEmpty()) // System.out.println("Oops, sorry, we could find a successful option"); // else // successes.forEach(System.out::println); }
public static void main(String[] args) { JUnitCore core = new JUnitCore(); core.addListener(new CalcListener()); core.run(MathFunctionTest.class); }
private Result runImpl(Test test) { JUnitCore runner = new JUnitCore(); TextListener txtListener = new TextListener(System.out); runner.addListener(txtListener); return runner.run(test); }
public ManagerRunningTests() { junit = new JUnitCore(); listener = new JUnitTestRunListener(); junit.addListener(listener); }
public static void userMain(String[] args) { H2O.main(args); TestUtil.stall_till_cloudsize(NODES); List<Class> tests = new ArrayList<Class>(); // Classes to test: // tests = JUnitRunner.all(); // Neural Net - deprecated // tests.add(NeuralNetSpiralsTest.class); //compare NeuralNet vs reference // tests.add(NeuralNetIrisTest.class); //compare NeuralNet vs reference // Chunk tests // tests.add(C0LChunkTest.class); // tests.add(C0DChunkTest.class); // tests.add(C1ChunkTest.class); // tests.add(C1NChunkTest.class); // tests.add(C1SChunkTest.class); // tests.add(C2ChunkTest.class); // tests.add(C2SChunkTest.class); // tests.add(C4ChunkTest.class); // tests.add(C4FChunkTest.class); // tests.add(C4SChunkTest.class); // tests.add(C8ChunkTest.class); // tests.add(C8DChunkTest.class); // tests.add(C16ChunkTest.class); // tests.add(CBSChunkTest.class); // tests.add(CX0ChunkTest.class); // tests.add(CXIChunkTest.class); // tests.add(CXDChunkTest.class); // tests.add(VecTest.class); // Deep Learning tests // tests.add(DeepLearningVsNeuralNet.class); //only passes for NODES=1, not clear why // tests.add(DeepLearningAutoEncoderTest.class); //test Deep Learning convergence // tests.add(DeepLearningAutoEncoderCategoricalTest.class); //test Deep Learning // convergence // tests.add(DeepLearningSpiralsTest.class); //test Deep Learning convergence // tests.add(DeepLearningIrisTest.Short.class); //compare Deep Learning vs reference // tests.add(DeepLearningIrisTest.Long.class); //compare Deep Learning vs reference tests.add(DeepLearningProstateTest.Short.class); // test Deep Learning // tests.add(DeepLearningMissingTest.class); //test Deep Learning // tests.add(DeepLearningProstateTest.Long.class); //test Deep Learning // tests.add(NeuronsTest.class); //test Deep Learning // tests.add(MRUtilsTest.class); //test MR sampling/rebalancing // tests.add(DropoutTest.class); //test NN Dropput // tests.add(ParserTest2.class); // tests.add(ParserTest2.ParseAllSmalldata.class); // tests.add(KMeans2Test.class); // tests.add(KMeans2RandomTest.class); // tests.add(GLMRandomTest.Short.class); // tests.add(SpeeDRFTest.class); // tests.add(SpeeDRFTest2.class); //// tests.add(GLMTest2.class); // tests.add(DRFTest.class); // tests.add(DRFTest2.class); // tests.add(GBMTest.class); // tests.add(KMeans2Test.class); // tests.add(PCATest.class); // tests.add(NetworkTestTest.class); // Uncomment this to sleep here and use the browser. // try { Thread.sleep(10000000); } catch (Exception _) {} JUnitCore junit = new JUnitCore(); junit.addListener(new LogListener()); Result result = junit.run(tests.toArray(new Class[0])); if (result.getFailures().size() == 0) { Log.info("SUCCESS!"); System.exit(0); } else { Log.info("FAIL!"); System.exit(1); } }
/** * Run all the tests contained in <code>request</code>. * * <p>This variant should be used if {@code core} has attached listeners that this run should * notify. * * @param request the request describing tests * @param core a JUnitCore to delegate to. * @return a {@link Result} describing the details of the test run and the failed tests. */ public Result run(Request request, JUnitCore core) { core.addListener(fHistory.listener()); return core.run(sortRequest(request).getRunner()); }