下面列出了org.junit.runner.Result#getFailureCount() 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public static void main(String[] args)
{
Class<?> clazz = MethodHandles.lookup().lookupClass();
Result result = new JUnitCore().run(clazz);
int exitCode;
if (result.getFailureCount() > 0)
{
Logger logger = LoggerFactory.getLogger(clazz);
result.getFailures().forEach(f ->
{
logger.error("Failure: {}", f);
logger.error(f.getTrace());
});
exitCode = ERROR_EXIT_CODE;
}
else
{
exitCode = calculateExitCode(BeanFactory.getBean(IRunStatusProvider.class).getRunStatus());
}
System.exit(exitCode);
}
/**
* Updates the current state of <code>this</code> with the <code>result</code>.
*
* @param testClass The test class executed.
* @param result The results of the test class execution.
* @return <code>this</code>
*/
public TestResults merge(Class<?> testClass, Result result) {
LOG.info("Tests run: {}, Failures: {}, Skipped: {}, Time elapsed: {} - in {}",
result.getRunCount(), result.getFailureCount(), result.getIgnoreCount(),
TimeUnit.SECONDS.convert(result.getRunTime(), TimeUnit.MILLISECONDS),
testClass.getName());
numRun += result.getRunCount();
numFailed += result.getFailureCount();
numIgnored += result.getIgnoreCount();
// Collect the failures
if (!result.wasSuccessful()) {
failures.addAll(result.getFailures());
}
return this;
}
private boolean isSynthesisPossible(final Result firstResultWithFalse, final Result secondResultWithTrue) {
// this method is a key optimization in Nopol
// it enables to not start the synthesis when we are sure that it is not possible
// only based on the observed test outcomes with angelic values
Collection<Description> testFailuresWithFalse = TestSuiteExecution.collectDescription(firstResultWithFalse.getFailures());
Collection<Description> testFailuresWithTrue = TestSuiteExecution.collectDescription(secondResultWithTrue.getFailures());
// contract: all test failures must either in testFailuresWithFalse or in secondFailures
// removes from testFailuresWithFalse all of its elements that are not contained in testFailuresWithTrue
// consequently, it remains the elements that are always failing
Collection<Description> testsThatAreAlwasyFailing = new ArrayList<>(testFailuresWithFalse);
testsThatAreAlwasyFailing.retainAll(testFailuresWithTrue);
boolean synthesisIsPossible = testsThatAreAlwasyFailing.isEmpty();
// some logging
int nbFirstSuccess = firstResultWithFalse.getRunCount() - firstResultWithFalse.getFailureCount();
int nbSecondSuccess = secondResultWithTrue.getRunCount() - secondResultWithTrue.getFailureCount();
if (!synthesisIsPossible || (nbFirstSuccess == 0 && nbSecondSuccess == 0)) {
Logger testsOutput = LoggerFactory.getLogger("tests.output");
testsOutput.debug("Failing tests with false: \n{}", firstResultWithFalse.getFailures());
testsOutput.debug("Failing tests with true: \n{}", secondResultWithTrue.getFailures());
}
return synthesisIsPossible;
}
/**
* 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, PrintStream out) {
JUnitCore junitCore = new JUnitCore();
junitCore.addListener(listener);
boolean hasError = false;
int numTests = 0;
int numFailures = 0;
long start = System.currentTimeMillis();
for (@AutoreleasePool Class c : classes) {
out.println("Running " + c.getName());
Result result = junitCore.run(c);
numTests += result.getRunCount();
numFailures += result.getFailureCount();
hasError = hasError || !result.wasSuccessful();
}
long end = System.currentTimeMillis();
out.println(String.format("Ran %d tests, %d failures. Total time: %s seconds", numTests, numFailures,
NumberFormat.getInstance().format((double) (end - start) / 1000)));
return hasError ? 1 : 0;
}
public static void main(String []argv)
{
int maxIterations = 10;
JUnitCore junit = new JUnitCore();
Result result = null;
int iter = 0;
do
{
result = junit.run(Request.method(TraversalsTests.class, "testDepthFirstOnCircle"));
iter++;
System.out.println("Failures " + result.getFailureCount());
if (result.getFailureCount() > 0)
{
for (Failure failure : result.getFailures())
{
failure.getException().printStackTrace();
}
}
} while (result.getFailureCount() == 0 && iter < maxIterations);
}
public static void main(String []argv)
{
JUnitCore junit = new JUnitCore();
Result result = null;
do
{
result = junit.run(Request.method(PropertyIndexingTests.class, "derivedPropertyIndexing"));
} while (result.getFailureCount() == 0 && false);
System.out.println("Failures " + result.getFailureCount());
if (result.getFailureCount() > 0)
{
for (Failure failure : result.getFailures())
{
failure.getException().printStackTrace();
}
}
System.exit(0);
}
public String createOutput(Result r) {
String out = "[";
int count = 0;
int failures = 0;
try {
for (Failure f : r.getFailures()) {
String s = failureMessage(f);
if (!s.startsWith("warning")) {
failures++;
}
out += s + "-,";
count++;
if (count > 10) {
out += "...and " + (r.getFailureCount() - 10) + " failures more,";
// break;
}
}
} catch (Exception e) {
// We do not care about this exception,
}
out = out + "]";
return (OUTSEP + r.getRunCount() + OUTSEP + failures + OUTSEP + out + OUTSEP);
}
@Test
public void testShardingIsSupported() {
config = createConfig();
shardingEnvironment = mock(ShardingEnvironment.class);
shardingFilters = new FakeShardingFilters(
Description.createTestDescription(SamplePassingTest.class, "testThatAlwaysPasses"),
Description.createTestDescription(SampleFailingTest.class, "testThatAlwaysFails"));
when(shardingEnvironment.isShardingEnabled()).thenReturn(true);
JUnit4Runner runner = createRunner(SampleSuite.class);
Result result = runner.run();
verify(shardingEnvironment).touchShardFile();
assertThat(result.getRunCount()).isEqualTo(2);
if (result.getFailureCount() > 1) {
fail("Too many failures: " + result.getFailures());
}
assertThat(result.getFailureCount()).isEqualTo(1);
assertThat(result.getIgnoreCount()).isEqualTo(0);
assertThat(runner.getModel().getNumTestCases()).isEqualTo(2);
}
protected boolean runBootstrapTest(RunNotifier notifier, TestClass testClass) {
if (!runningBootstrapTest.get().booleanValue()) {
runningBootstrapTest.set(Boolean.TRUE);
try {
BootstrapTest bootstrapTest = getBootstrapTestAnnotation(testClass.getJavaClass());
if (bootstrapTest != null) {
Result result = JUnitCore.runClasses(bootstrapTest.value());
List<Failure> failures = result.getFailures();
for (Failure failure : failures) {
notifier.fireTestFailure(failure);
}
return result.getFailureCount() == 0;
} else {
throw new IllegalStateException("LoadTimeWeavableTestRunner, must be coupled with an @BootstrapTest annotation to define the bootstrap test to execute.");
}
} finally {
runningBootstrapTest.set(Boolean.FALSE);
}
}
return true;
}
public static void main(String[] args) {
try {
H2O.main(args);
TestUtil.stall_till_cloudsize(3);
List<Class> tests = JUnitRunner.all();
Result r = org.junit.runner.JUnitCore.runClasses(tests.toArray(new Class[0]));
if( r.getFailureCount() == 0 ) {
System.out.println("Successfully ran the following tests in " + (r.getRunTime() / 1000) + "s");
for( Class c : tests )
System.out.println(c.getName());
} else {
for( Failure f : r.getFailures() ) {
System.err.println(f.getDescription());
if( f.getException() != null )
f.getException().printStackTrace();
}
}
System.exit(r.getFailureCount());
} catch( Throwable t ) {
t.printStackTrace();
System.exit(1);
}
}
public UnitTestResult(Result jr) {
this.runCount = jr.getRunCount();
this.failureCount = jr.getFailureCount();
this.runTime = jr.getRunTime();
this.ignoreCount = jr.getIgnoreCount();
this.successful = jr.wasSuccessful();
}
public TestResult(Result result) {
runCount = result.getRunCount();
failureCount = result.getFailureCount();
ignoreCount = result.getIgnoreCount();
runTime = result.getRunTime();
if (!wasSuccessful()) {
throwable = result.getFailures().get(0).getException();
}
}
private void computeMethodCoverage() throws IOException{
JUnitRuntime runtime = new JUnitRuntime(_subject);
String src = _subject.getHome() + _subject.getSsrc();
MethodInstrumentVisitor methodInstrumentVisitor = new MethodInstrumentVisitor();
Instrument.execute(src, methodInstrumentVisitor);
if(!Runner.compileSubject(_subject)){
System.err.println("Build project failed!");
System.exit(0);
}
System.out.println("Passed test classes : " + _localization.getPassedTestCases().size());
for(String test : _localization.getPassedTestCases()){
String[] testStr = test.split("#");
String clazz = testStr[0];
String methodName = testStr[1];
OutStream outStream = new OutStream();
Result result = JUnitEngine.getInstance(runtime).test(clazz, methodName, new PrintStream(outStream));
if(result.getFailureCount() > 0){
System.out.println("Error : Passed test cases running failed ! => " + clazz);
System.exit(0);
}
for(Integer method : outStream.getOut()){
Set<Pair<String, String>> tcases = _passedTestCasesMap.get(method);
if(tcases == null){
tcases = new HashSet<>();
}
tcases.add(new Pair<String, String>(clazz, methodName));
_passedTestCasesMap.put(method, tcases);
}
}
// restore source file
_subject.restore();
}
protected void assertFailureCount(int expected, Result result) {
if (result.getFailureCount() != expected) {
StringBuilder b = new StringBuilder();
for (Failure f : result.getFailures()) {
b.append("\n\n");
b.append(f.getMessage());
b.append("\n");
b.append(f.getTrace());
}
Assert.assertFalse("Expected failures: " + expected + " but was " +
result.getFailureCount() + ", failures below: " + b.toString(), true);
}
}
private static void checkThatAllTestsPass(Class<?> TEST_CLASS) {
resetAllSelectors();
JUnitCore core = new JUnitCore();
Result result = core.run(TEST_CLASS);
if (result.getFailureCount()>0) {
// oops the tests are not valid before
throw new RuntimeException("oops it does not pass anymore", result.getFailures().get(0).getException());
}
}
private boolean executeTestAndCollectRuntimeValues(Object result,
TestCase currentTest, ClassLoader unitTestClassLoader,
SpecificationTestCasesListener<T> listener) {
LoggingInstrumenter.setValue(result);
Result testResult = TestSuiteExecution.runTestCase(currentTest,
unitTestClassLoader, listener, nopolContext);
if (testResult.getFailureCount() == 0) {
return true;
}
return false;
}
public static void main(String [] argv)
{
JUnitCore junit = new JUnitCore();
Result result = null;
result = junit.run(Request.method(TestParser.class, "malformedTest4"));
if (result.getFailureCount() > 0)
{
for (Failure failure : result.getFailures())
{
failure.getException().printStackTrace();
}
}
System.exit(0);
}
public static void run(final Class... suites) {
boolean underTC = System.getenv(TEAMCITY_DETECT_VAR_NAME) != null;
// prepare junit
JUnitSystem system = new RealSystem();
JUnitCore core = new JUnitCore();
RunListener listener = underTC ? new TeamCityListener() : new TextListener(system);
core.addListener(listener);
int success = 0,
failures = 0,
ignores = 0;
// run tests
for (Class suite : suites) {
sayNothing();
String suiteName = suite.getSimpleName();
if (suiteName.endsWith("Tests")) suiteName = suiteName.substring(0, suiteName.length()-"Tests".length());
if (suiteName.endsWith("Integration")) suiteName = suiteName.substring(0, suiteName.length()-"Integration".length());
if (suiteParameter != null) suiteName = suiteName + '[' + suiteParameter + ']';
if (underTC) say("##teamcity[testSuiteStarted name='%s']", suiteName);
Result result = core.run(suite);
success += result.getRunCount() - (result.getFailureCount() + result.getIgnoreCount());
failures += result.getFailureCount();
ignores += result.getIgnoreCount();
if (underTC) say("##teamcity[testSuiteFinished name='%s']", suiteName);
sayNothing();
}
}
@Test
public void test() {
Request request = Request.method(testMethod.getDeclaringClass(), testMethod.getName());
Result result = new JUnitCore().run(request);
if (result.getIgnoreCount() > 0)
throw new AssumptionViolatedException("Test " + testMethod.getDeclaringClass()
+ "." + testMethod.getName() + " were ignored");
if (result.getFailureCount() > 0) {
Assert.fail(result.getFailures().toString());
}
}
private static int getFailureCount(Result result) {
if (result == null) {
return -1;
}
return result.getFailureCount();
}