private List<org.junit.rules.MethodRule> getMethodRules(Object target) { return rules(target); }
private Statement withRules(FrameworkMethod method, Object target, Statement statement) { RuleContainer ruleContainer = new RuleContainer(); CURRENT_RULE_CONTAINER.set(ruleContainer); try { List<TestRule> testRules = getTestRules(target); for (MethodRule each : rules(target)) { if (!(each instanceof TestRule && testRules.contains(each))) { ruleContainer.add(each); } } for (TestRule rule : testRules) { ruleContainer.add(rule); } } finally { CURRENT_RULE_CONTAINER.remove(); } return ruleContainer.apply(method, describeChild(method), target, statement); }
private List<org.junit.rules.MethodRule> getMethodRules(Object target) { return rules(target); }
private List<org.junit.rules.MethodRule> getMethodRules(Object target) { return rules(target); }
private List<org.junit.rules.MethodRule> getMethodRules(Object target) { return rules(target); }
private List<org.junit.rules.MethodRule> getMethodRules(Object target) { return rules(target); }
private List<org.junit.rules.MethodRule> getMethodRules(Object target) { return rules(target); }
@Override protected List<MethodRule> rules(final Object test) { final List<MethodRule> rules = super.rules(test); rules.add(new MethodRule() { public Statement apply(final Statement base, final FrameworkMethod method, final Object target) { return new DeployApplication(target, base, delegate); } }); return rules; } }
@Override protected List<MethodRule> rules(final Object test) { final List<MethodRule> rules = super.rules(test); rules.add(new MethodRule() { public Statement apply(final Statement base, final FrameworkMethod method, final Object target) { return new DeployApplication(target, base, delegate); } }); return rules; } }
@Override protected List<MethodRule> rules(final Object test) { List<MethodRule> rules = super.rules(test); rules.add(new MethodRule() { @Override public Statement apply(final Statement base, final FrameworkMethod method, final Object target) { return new JUnitWatchman().apply(base, method, target); } }); return rules; }
@Override protected List<MethodRule> rules(Object test) { final LinkedList<MethodRule> methodRules = new LinkedList<MethodRule>(super.rules(test)); methodRules.add(new ActiveObjectTransactionMethodRule(test, jdbcConfiguration, tableNameConverter, fieldNameConverter, sequenceNameConverter, triggerNameConverter, indexNameConverter, uniqueNameConverter)); return methodRules; }
@Override protected List<MethodRule> rules(Object target) { List<MethodRule> rules = super.rules(target); rules.add(moonshineRule.injectMembers(target)); rules.add(new MockitoRule()); return rules; } }
@Override protected List<MethodRule> rules(Object test) { List<MethodRule> result = super.rules(test); for (MethodRule methodRule : result) { if (WorkflowTestBase.class.isAssignableFrom(methodRule.getClass())) { workflowTestRule = (WorkflowTestBase) methodRule; workflowTestRule.setFlowTestRunner(true); if (timeout > 0) { workflowTestRule.setTestTimeoutActualTimeMilliseconds(timeout); } workflowTestRule.setExpectedException(expectedException); } } return result; }
@Override protected List<MethodRule> rules(Object target) { LinkedList<MethodRule> rules = new LinkedList<>(); rules.add(loggerRule); rules.addAll(super.rules(target)); rules.add(checkDB); return rules; }
@Override protected List<MethodRule> rules(Object test) { List<MethodRule> result = super.rules(test); for (MethodRule methodRule : result) { if (WorkflowTestBase.class.isAssignableFrom(methodRule.getClass())) { workflowTestRule = (WorkflowTestBase) methodRule; workflowTestRule.setFlowTestRunner(true); if (timeout > 0) { workflowTestRule.setTestTimeoutActualTimeMilliseconds(timeout); } if (expectedException != null) { workflowTestRule.setExpectedException(expectedException); } } } return result; }
@Override protected List<MethodRule> rules(Object test) { verify(test instanceof JPATest, "In order to use the %s for %s, it should (directly or indirectly) implement %s", JPATestRunner.class.getSimpleName(), test.getClass(), JPATest.class); List<MethodRule> rules = super.rules(test); rules.add(new MethodRule() { @Override public Statement apply(final Statement base, FrameworkMethod method, final Object target) { return new Statement() { @Override public void evaluate() throws Throwable { ((JPATest) target).setEntityManager(entityManager); base.evaluate(); } }; } }); return rules; }
@Override protected List<MethodRule> rules(Object test) { verify(test instanceof JPATest, "In order to use the %s for %s, it should (directly or indirectly) implement %s", JPATestRunner.class.getSimpleName(), test.getClass(), JPATest.class); List<MethodRule> rules = super.rules(test); rules.add(new MethodRule() { @Override public Statement apply(final Statement base, FrameworkMethod method, final Object target) { return new Statement() { @Override public void evaluate() throws Throwable { ((JPATest) target).setEntityManager(entityManager); base.evaluate(); } }; } }); return rules; }
@Override protected List<MethodRule> rules(Object test) { verify(test instanceof HibernateTest, "In order to use the %s for %s, it should (directly or indirectly) implement %s", HibernateTestRunner.class.getSimpleName(), test.getClass(), HibernateTest.class); List<MethodRule> rules = super.rules(test); rules.add(new MethodRule() { @Override public Statement apply(final Statement base, FrameworkMethod method, final Object target) { return new Statement() { @Override public void evaluate() throws Throwable { ((HibernateTest) target).setSession(session); base.evaluate(); } }; } }); return rules; }
@Override protected List<MethodRule> rules(Object target) { List<MethodRule> methodRules = super.rules(target); for (ITRunnerPlugin plugin : plugins) { for (Class<? extends MethodRule> methodRuleClass : plugin.provideMethodRulesToApply(getTestClass(), target)) { try { methodRules.add(instantiate(methodRuleClass)); } catch (Exception e) { throw SeedException.wrap(e, ITErrorCode.FAILED_TO_INSTANTIATE_TEST_RULE).put("class", methodRuleClass); } } } return methodRules; }
@Override protected List<MethodRule> rules(final Object target) { return registerRules(super.rules(target), executor, JpaUnitContext.getInstance(getTestClass().getJavaClass())); } }