org.junit.runner.notification.RunNotifier Java Examples

@Override
protected void runChild(Spec spec, RunNotifier notifier) {
	List<Spec> specs = spec.getSuite().getSpecs();
	boolean suiteHasNoSpecs = specs.isEmpty();
	boolean isFirstSpec = specs.indexOf(spec) == 0;
	boolean isLastSpec = specs.indexOf(spec) == specs.size() -1;

	if (suiteHasNoSpecs || isFirstSpec){
		runBeforeCallbacks(spec);
	}

	if (spec.getBlock().isPresent()) {
		runBeforeEachCallbacks(spec);
		runLeaf(spec, describeChild(spec), notifier);
		runAfterEachCallbacks(spec);
	} else {
		notifier.fireTestIgnored(describeChild(spec));
	}


	if (suiteHasNoSpecs || isLastSpec){
		runAfterCallbacks(spec);
	}
}
 

/**
 * Runs the test corresponding to {@code child}, which can be assumed to be
 * an element of the list returned by {@link ParentRunner#getChildren()}.
 * Subclasses are responsible for making sure that relevant test events are
 * reported through {@code notifier}
 *
 * @param child
 * @param notifier
 */
@Override
protected void runChild(ScenarioSpec child, RunNotifier notifier) {

    final Description description = Description.createTestDescription(testClass, child.getScenarioName());

    // ----------------------------------------------
    // Notify that this single test has been started.
    // Supply the scenario/journey name
    // ----------------------------------------------
    notifier.fireTestStarted(description);

    passed = zeroCodeMultiStepsScenarioRunner.runScenario(child, notifier, description);

    testRunCompleted = true;

    if (passed) {
        LOGGER.info(String.format("\nPackageRunner- **FINISHED executing all Steps for [%s] **.\nSteps were:%s",
                child.getScenarioName(),
                child.getSteps().stream().map(step -> step.getName()).collect(Collectors.toList())));
    }

    notifier.fireTestFinished(description);

}
 

@Override
@SneakyThrows
public void run(RunNotifier notifier) {
    System.out.println("running the tests from SmartAssert: " + test);
    Object testObject = test.newInstance();
    for (Method method : test.getMethods()) {
        if (!method.isAnnotationPresent(Test.class)) continue;

        notifier.fireTestStarted(description(method));

        method.invoke(testObject);
        checkResult(failures(test.getName()));

        notifier.fireTestFinished(description(method));
    }
}
 

/**
 * Before to delegate to the {@linkplain BlockJUnit4ClassRunner#runChild default implementation},
 * check if a dependency of the given method failed. In such case, the test will be ignored.
 *
 * @param  method    the test method to execute.
 * @param  notifier  the object to notify about test results.
 */
@Override
protected void runChild(final FrameworkMethod method, final RunNotifier notifier) {
    if (skipAll) {
        notifier.fireTestIgnored(describeChild(method));
        return;
    }
    if (methodDependencyFailures != null) {
        final DependsOnMethod assumptions = method.getAnnotation(DependsOnMethod.class);
        if (assumptions != null) {
            for (final String assumption : assumptions.value()) {
                if (methodDependencyFailures.contains(assumption)) {
                    methodDependencyFailures.add(method.getName());
                    notifier.fireTestIgnored(describeChild(method));
                    return;
                }
            }
        }
    }
    super.runChild(method, notifier);
}
 

private void invokeTest(RunNotifier notifier, TestExecutorType type, FrameworkMethod method) {
    if ((type == null) || TestExecutorType.LOCAL.equals(type)) {
        runLeaf(methodBlock(method), describeChild(method), notifier);
    } else {
        EachTestNotifier eachNotifier = new EachTestNotifier(notifier, describeChild(method));
        try {
            eachNotifier.fireTestStarted();
            execute(type, method.getMethod()).get();
        } catch (Throwable e) {
            log.error("Test " + method + " failed with exception ", e);
            eachNotifier.addFailure(unwrap(e));
        } finally {
            eachNotifier.fireTestFinished();
        }
    }
}
 

@Override
public void runChild(final FrameworkMethod method, final RunNotifier notifier) {
    final Description description = describeChild(method);
    if (this.isIgnored(method)) {
        notifier.fireTestIgnored(description);
    } else {
        final EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
        eachNotifier.fireTestStarted();
        boolean ignored = false;
        try {
            this.methodBlock(method).evaluate();
        } catch (AssumptionViolatedException ave) {
            eachNotifier.addFailedAssumption(ave);
        } catch (Throwable e) {
            if (validateForGraphComputer(e)) {
                eachNotifier.fireTestIgnored();
                logger.info(e.getMessage());
                ignored = true;
            } else
                eachNotifier.addFailure(e);
        } finally {
            if (!ignored)
                eachNotifier.fireTestFinished();
        }
    }
}
 

private static void runInternal(final RunNotifier notifier) {
    if (openssl && OPENSSL_FAILURE != null) {
        throw new RuntimeException(OPENSSL_FAILURE);
    }
    if (first) {
        first = false;
        undertow = Undertow.builder()
                .setHandler(rootHandler)
                .addHttpListener(getHostPort(DEFAULT), getHostAddress(DEFAULT))
                .build();
        undertow.start();
        notifier.addListener(new RunListener() {
            @Override
            public void testRunFinished(Result result) throws Exception {
                super.testRunFinished(result);
                undertow.stop();
                clientGroup.shutdownGracefully();
            }
        });
    }
}
 

@Override
public void run(RunNotifier notifier) {
    System.out.println("running the tests from MyRunner. " + testClass);
    try {
        Object testObject = testClass.newInstance();
        for (Method method : testClass.getMethods()) {
            if (method.isAnnotationPresent(Test.class)) {
                notifier.fireTestStarted(Description.EMPTY);
                method.invoke(testObject);
                notifier.fireTestFinished(Description.EMPTY);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}
 

@Override
protected Statement classBlock(RunNotifier notifier) {
  final Statement suite = super.classBlock(notifier);

  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      TestEnvironment testEnvironment = null;
      try {
        testEnvironment = GlobalTestEnvironment.getOrCreate(InProcessTestEnvironment::new);
        suite.evaluate();
      } finally {
        if (testEnvironment != null) {
          testEnvironment.stop();
        }
        if (driverSupplier instanceof Closeable) {
          ((Closeable) driverSupplier).close();
        }
      }
    }
  };
}
 

@Override
protected void runChild(TestMapping[] childArrayElement, RunNotifier notifier) {
    notifier.fireTestStarted(testDescription);

    Arrays.stream(childArrayElement).forEach(thisChild -> {
        loadProcessor.addTest(thisChild.testClass(), thisChild.testMethod());
    });

    boolean hasFailed = loadProcessor.processMultiLoad();

    if (hasFailed) {
        String failureMessage = testClass.getName() + " with load/stress test(s): " + testDescription + " have Failed";
        LOGGER.error(failureMessage + ". See target/logs -or- junit granular failure report(csv) -or- fuzzy search and filter report(html) for details");
        notifier.fireTestFailure(new Failure(testDescription, new RuntimeException(failureMessage)));
    }
    notifier.fireTestFinished(testDescription);
}
 

private Boolean executeRetryWithSteps(RunNotifier notifier,
                                      Description description,
                                      ScenarioExecutionState scenarioExecutionState,
                                      ScenarioSpec scenario, Step thisStep) {
    thisStep = extFileProcessor.resolveExtJsonFile(thisStep);
    List<Step> thisSteps = extFileProcessor.createFromStepFile(thisStep, thisStep.getId());
    if(null == thisSteps || thisSteps.isEmpty()) thisSteps.add(thisStep);
    Boolean wasExecSuccess = null;
    for(Step step : thisSteps) {
         wasExecSuccess = executeRetry(notifier,
                description,
                scenarioExecutionState,
                scenario,
                step);
        if (wasExecSuccess != null) {
            return wasExecSuccess;
        }
    }
    return null;
}
 

@Override
public void run(RunNotifier notifier) {
    RunListener listener = new RunListener() {
        WarningsCollector warningsCollector;
        
        @Override
        public void testStarted(Description description) throws Exception {
            warningsCollector = new WarningsCollector();
        }
        
        @Override public void testFailure(Failure failure) throws Exception {                
            logger.log(warningsCollector.getWarnings());
        }
    };

    notifier.addListener(listener);

    runner.run(notifier);
}
 

@Override
protected void runChild(final FrameworkMethod method, final RunNotifier notifier)
{
    BrokerSpecific brokerSpecific = method.getAnnotation(BrokerSpecific.class);
    if (brokerSpecific == null)
    {
        brokerSpecific = method.getDeclaringClass().getAnnotation(BrokerSpecific.class);
    }
    if (brokerSpecific != null && !brokerSpecific.kind().equalsIgnoreCase(_brokerAdmin.getKind()))
    {
        notifier.fireTestIgnored(describeChild(method));
    }
    else
    {
        _brokerAdmin.beforeTestMethod(_testClass, method.getMethod());
        try
        {
            super.runChild(method, notifier);
        }
        finally
        {
            _brokerAdmin.afterTestMethod(_testClass, method.getMethod());
        }
    }
}
 

public void run(RunNotifier notifier) {
  for (JmesPathComplianceTest.ComplianceTest<T> complianceTest : getAllTests()) {
    Description testDescription = createDescription(complianceTest);
    notifier.fireTestStarted(testDescription);
    try {
      complianceTest.run();
    } catch (AssertionError ae) {
      notifier.fireTestFailure(new Failure(testDescription, ae));
    } catch (Exception e) {
      notifier.fireTestFailure(new Failure(testDescription, e));
    } finally {
      notifier.fireTestFinished(testDescription);
    }
  }
}
 

@Override
public void run(final RunNotifier notifier) {
    if (!SystemUtils.JAVA_VERSION.startsWith("1.8.")) {
        notifier.fireTestAssumptionFailed(new Failure(
                Description.createSuiteDescription(clazz),
                new IllegalStateException("Java " + SystemUtils.JAVA_VERSION + " not yet supported")));
    } else {
        super.run(notifier);
    }
}
 

private void runEnabledTests(RunNotifier nested) {
    if (enabledTests.isEmpty()) {
        return;
    }

    Runner runner;
    try {
        runner = createExecutionRunner();
    } catch (Throwable t) {
        runner = new CannotExecuteRunner(getDisplayName(), target, t);
    }

    try {
        if (!disabledTests.isEmpty()) {
            ((Filterable) runner).filter(new Filter() {
                @Override
                public boolean shouldRun(Description description) {
                    return !disabledTests.contains(description);
                }

                @Override
                public String describe() {
                    return "disabled tests";
                }
            });
        }
    } catch (NoTestsRemainException e) {
        return;
    }

    runner.run(nested);
}
 

@Override
protected Statement classBlock(RunNotifier notifier) {
    final Statement statement = super.classBlock(notifier);
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            try {
                statement.evaluate();
            } finally {
                cache.clear(getTestClass().getJavaClass());
            }
        }
    };
}
 

@Override
public void run(RunNotifier notifier) {
    ClassLoader oldClassLoader = ClassLoaderUtils.pushContextClassLoader(DelegateArkContainer
        .getTestClassLoader());
    try {
        notifier.addListener(JUnitExecutionListener.getRunListener());
        runner.run(notifier);
    } finally {
        ClassLoaderUtils.popContextClassLoader(oldClassLoader);
    }
}
 

@Override
public void run(RunNotifier notifier) {
  notifier.fireTestStarted(description);
  try {
    testStatement.evaluate();
  } catch (Throwable throwable) {
    Failure failure = new Failure(description, throwable);
    notifier.fireTestFailure(failure);
  } finally {
    notifier.fireTestFinished(description);
  }
}
 

public static Failure runAndRecordFailure(HavaRunner havaRunner) {
    final AtomicReference<Failure> expectedFailure = new AtomicReference<>();
    RunNotifier runNotifier = new RunNotifier() {
        @Override
        public void fireTestFailure(Failure failure) {
            expectedFailure.set(failure);
        }
    };
    run(havaRunner, runNotifier);
    return expectedFailure.get();
}
 

@Override
public void run(final RunNotifier notifier) {
    if (!SystemUtils.JAVA_VERSION.startsWith("1.8.")) {
        notifier.fireTestAssumptionFailed(new Failure(
                Description.createSuiteDescription(clazz),
                new IllegalStateException("Java " + SystemUtils.JAVA_VERSION + " not yet supported")));
    } else {
        super.run(notifier);
    }
}
 

@Override
public void run(RunNotifier notifier) {
  if (properties.getProperty(CLOUD_PROVIDER, CLOUDPROVIDER_LOCAL).equals(CLOUDPROVIDER_AWS)) {
    awsRunner.run(notifier);
  } else {
    super.run(notifier);
  }
}
 

@Override
public void run(RunNotifier notifier) {
    ZeroCodeTestReportListener reportListener = new ZeroCodeTestReportListener(smartUtils.getMapper(), getInjectedReportGenerator());
    notifier.addListener(reportListener);

    LOGGER.info("System property " + ZEROCODE_JUNIT + "=" + getProperty(ZEROCODE_JUNIT));
    if (!CHARTS_AND_CSV.equals(getProperty(ZEROCODE_JUNIT))) {
        notifier.addListener(reportListener);
    }

    super.run(notifier);

    handleNoRunListenerReport(reportListener);
}
 

@Override
public void run(RunNotifier notifier) {
    initDescription();
    for (Execution execution : executions) {
        execution.run(notifier);
    }
}
 

/**
 * Runs the tests for this runner, but wraps the specified {@code notifier} with a {@link
 * DelegateRunNotifier} that intercepts calls to the original {@code notifier}. The {@link
 * DelegateRunNotifier} is what enables us to impose our default timeout.
 */
@Override
public void run(RunNotifier notifier) {
  DelegateRunNotifier wrapper =
      new DelegateRunNotifier(delegate, notifier, defaultTestTimeoutMillis);

  if (wrapper.hasJunitTimeout(getDescription())) {
    runWithoutBuckManagedTimeout(wrapper);
  } else {
    runWithBuckManagedTimeout(wrapper);
  }
}
 

@Override
public void run(RunNotifier notifier) {
    initDescription();
    for (Execution execution : executions) {
        execution.run(notifier);
    }
}
 

@Override
public void run(RunNotifier notifier) {
    if (GraphicsEnvironment.isHeadless()) {
        notifier.fireTestIgnored(getDescription());
        return;
    }
    super.run(notifier);
}
 

@Override
protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
  Description description = describeChild(method);
  if (method.getAnnotation(Ignore.class) != null) {
    notifier.fireTestIgnored(description);
  } else {
    runTest(methodBlock(method), description, notifier);
  }
}
 

protected void reportResults(final RunNotifier notifier, final SpecificationReport spec, final Description test) {
    switch (spec.getResult()) {
        case SUCCESS:
            notifier.fireTestFinished(test);
            return;
        case FAILURE:
            notifier.fireTestFailure(new Failure(test, spec.getCause()));
            return;
        case ERROR:
        default:
            throw new SpecificationError(spec.getMessage(), spec.getCause());
    }
}
 

@Override
protected void runChild(FrameworkMethod method, RunNotifier notifier)
{
    // clear the context before next child run
    Neodymium.clearThreadContext();
    super.runChild(method, notifier);
}