@Override
protected Statement methodBlock(FrameworkMethod frameworkMethod) {
    Object testInstance;
    try {
        testInstance = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                Description description = describeChild(frameworkMethod);
                return createTest(description);
            }
        }.run();
    }
    catch (Throwable ex) {
        return new Fail(ex);
    }


    Statement statement = methodInvoker(frameworkMethod, testInstance);
    statement = possiblyExpectingExceptions(frameworkMethod, testInstance, statement);
    statement = withBefores(frameworkMethod, testInstance, statement);
    if(!ColaMockito.g().getContext().isRecording()) {
        statement = withColaBefores(frameworkMethod, testInstance, statement);
    }
    statement = withAfters(frameworkMethod, testInstance, statement);
    return statement;
}
 

/**
 * Augment the default JUnit behavior
 * {@linkplain #withPotentialRepeat with potential repeats} of the entire
 * execution chain.
 * <p>Furthermore, support for timeouts has been moved down the execution
 * chain in order to include execution of {@link org.junit.Before @Before}
 * and {@link org.junit.After @After} methods within the timed execution.
 * Note that this differs from the default JUnit behavior of executing
 * {@code @Before} and {@code @After} methods in the main thread while
 * executing the actual test method in a separate thread. Thus, the net
 * effect is that {@code @Before} and {@code @After} methods will be
 * executed in the same thread as the test method. As a consequence,
 * JUnit-specified timeouts will work fine in combination with Spring
 * transactions. However, JUnit-specific timeouts still differ from
 * Spring-specific timeouts in that the former execute in a separate
 * thread while the latter simply execute in the main thread (like regular
 * tests).
 * @see #possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
 * @see #withBefores(FrameworkMethod, Object, Statement)
 * @see #withAfters(FrameworkMethod, Object, Statement)
 * @see #withRulesReflectively(FrameworkMethod, Object, Statement)
 * @see #withPotentialRepeat(FrameworkMethod, Object, Statement)
 * @see #withPotentialTimeout(FrameworkMethod, Object, Statement)
 */
@Override
protected Statement methodBlock(FrameworkMethod frameworkMethod) {
	Object testInstance;
	try {
		testInstance = new ReflectiveCallable() {
			@Override
			protected Object runReflectiveCall() throws Throwable {
				return createTest();
			}
		}.run();
	}
	catch (Throwable ex) {
		return new Fail(ex);
	}

	Statement statement = methodInvoker(frameworkMethod, testInstance);
	statement = possiblyExpectingExceptions(frameworkMethod, testInstance, statement);
	statement = withBefores(frameworkMethod, testInstance, statement);
	statement = withAfters(frameworkMethod, testInstance, statement);
	statement = withRulesReflectively(frameworkMethod, testInstance, statement);
	statement = withPotentialRepeat(frameworkMethod, testInstance, statement);
	statement = withPotentialTimeout(frameworkMethod, testInstance, statement);
	return statement;
}
 

@Override
protected Statement methodBlock(final FrameworkMethod method) {
    final Object test;
    try {
        test = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest();
            }
        }.run();
    } catch (final Throwable e) {
        return new Fail(e);
    }
    Statement statement = new MetaTest.$(method, test);
    statement = withBefores(method, test, statement);
    statement = withAfters(method, test, statement);
    return statement;
}
 

@Override
protected Statement methodBlock(final FrameworkMethod method) {
    final Object test;
    try {
        test = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest();
            }
        }.run();
    } catch (final Throwable e) {
        return new Fail(e);
    }
    Statement statement = new InvokeMethod(method, test);
    statement = withBefores(method, test, statement);
    statement = withAfters(method, test, statement);
    return statement;
}
 

/** Creates the test statement for a testDescriptor */
private Statement methodBlock(EndToEndTestDescriptor testDescriptor) {
  Object test;
  try {
    test =
        new ReflectiveCallable() {
          @Override
          protected Object runReflectiveCall() throws Throwable {
            return createTest();
          }
        }.run();
  } catch (Throwable e) {
    return new Fail(e);
  }

  Statement statement = new BuckInvoker(testDescriptor, test);
  statement = withBefores(test, statement);
  statement = withAfters(test, statement);
  statement = withExpectedExceptions(testDescriptor, statement);
  statement = withRules(testDescriptor, test, statement);
  return statement;
}
 

public Object invokeExplosively(final Object target, final Object... params)
        throws Throwable {
    return new ReflectiveCallable() {
        @Override
        protected Object runReflectiveCall() throws Throwable {
            performanceRecording.start(testExecutionContext);
            try {
                return method.invoke(target, params);
            } finally {
                performanceRecording.stop(testExecutionContext);
            }
        }
    }.run();
}
 

/**
 * Augments the default JUnit behavior
 * {@link #withPotentialRepeat(FrameworkMethod, Object, Statement) with
 * potential repeats} of the entire execution chain.
 * <p>
 * Furthermore, support for timeouts has been moved down the execution chain
 * in order to include execution of {@link org.junit.Before &#064;Before}
 * and {@link org.junit.After &#064;After} methods within the timed
 * execution. Note that this differs from the default JUnit behavior of
 * executing <code>&#064;Before</code> and <code>&#064;After</code> methods
 * in the main thread while executing the actual test method in a separate
 * thread. Thus, the end effect is that <code>&#064;Before</code> and
 * <code>&#064;After</code> methods will be executed in the same thread as
 * the test method. As a consequence, JUnit-specified timeouts will work
 * fine in combination with Spring transactions. Note that JUnit-specific
 * timeouts still differ from Spring-specific timeouts in that the former
 * execute in a separate thread while the latter simply execute in the main
 * thread (like regular tests).
 * </p>
 *
 * @see #possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
 * @see #withBefores(FrameworkMethod, Object, Statement)
 * @see #withAfters(FrameworkMethod, Object, Statement)
 * @see #withPotentialTimeout(FrameworkMethod, Object, Statement)
 * @see #withPotentialRepeat(FrameworkMethod, Object, Statement)
 */
@Override
protected Statement methodBlock(FrameworkMethod frameworkMethod) {

  Object testInstance;
  try {
    testInstance = new ReflectiveCallable() {

      @Override
      protected Object runReflectiveCall() throws Throwable {
        return createTest();
      }
    }.run();
  } catch (Throwable e) {
    return new Fail(e);
  }

  Statement statement = methodInvoker(frameworkMethod, testInstance);
  statement = possiblyExpectingExceptions(frameworkMethod, testInstance, statement);
  statement = withRulesReflectively(frameworkMethod, testInstance, statement);
  statement = withBefores(frameworkMethod, testInstance, statement);
  statement = withAfters(frameworkMethod, testInstance, statement);
  statement = withPotentialRepeat(frameworkMethod, testInstance, statement);
  statement = withPotentialTimeout(frameworkMethod, testInstance, statement);

  return statement;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void beforeInvocation(final Object runner, final FrameworkMethod method, final ReflectiveCallable callable) {
    try {
        Object obj = LifecycleHooks.getFieldValue(callable, "val$target");
        DriverManager.beforeInvocation(obj, method.getMethod());
    } catch (IllegalAccessException | NoSuchFieldException | SecurityException e) {
        UncheckedThrow.throwUnchecked(e);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public void afterInvocation(final Object runner, final FrameworkMethod method, final ReflectiveCallable callable, final Throwable thrown) {
    try {
        Object obj = LifecycleHooks.getFieldValue(callable, "val$target");
        DriverManager.afterInvocation(obj, method.getMethod());
    } catch (IllegalAccessException | NoSuchFieldException | SecurityException e) {
        UncheckedThrow.throwUnchecked(e);
    }
}
 

@Override public Object invokeExplosively(final Object target, Object... params)
    throws Throwable {
  checkNotNull(target, "target");

  ReflectiveCallable callable = new ReflectiveCallable() {
    @Override protected Object runReflectiveCall() throws Throwable {
      return getMethod().invoke(target, methodArgs);
    }
  };
  return callable.run();
}
 

/**
 * Creates a new test instance
 *
 * @return new instance
 */
private Object newTestInstance() {
    try {
        return new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest();
            }
        }.run();
    } catch (final Throwable e) {
        return new Fail(e);
    }
}
 

/**
 * Creates a new test instance
 *
 * @return new instance
 */
private Object newTestInstance() {
    try {
        return new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest();
            }
        }.run();
    } catch (final Throwable e) {
        return new Fail(e);
    }
}
 

@Override
@SuppressWarnings("deprecation")
protected Statement methodBlock(final FrameworkMethod method) {
    final Object test;
    final WebTestCase testCase;
    try {
        testCase = (WebTestCase) createTest();
        test = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return testCase;
            }
        } .run();
    }
    catch (final Throwable e) {
        return new Fail(e);
    }

    Statement statement = methodInvoker(method, test);
    statement = possiblyExpectingExceptions(method, test, statement);
    statement = withPotentialTimeout(method, test, statement);
    statement = withBefores(method, test, statement);
    statement = withAfters(method, test, statement);
    statement = withRules(method, test, statement);

    //  End of copy & paste from super.methodBlock()  //

    boolean notYetImplemented = false;
    final int tries;

    if (testCase instanceof WebDriverTestCase && realBrowser_) {
        tries = 1;
    }
    else {
        notYetImplemented = isNotYetImplemented(method);
        tries = getTries(method);
    }
    if (method instanceof StandardsFrameworkMethod && ((StandardsFrameworkMethod) method).isStandards()) {
        setAlertsStandards(testCase, method.getMethod());
    }
    else {
        setAlerts(testCase, method.getMethod());
    }
    statement = new BrowserStatement(statement, method, realBrowser_,
            notYetImplemented, tries, browserVersion_);
    return statement;
}
 

/**
 * Returns a Statement that, when executed, either returns normally if
 * {@code method} passes, or throws an exception if {@code method} fails.
 *
 * Here is an outline of the default implementation:
 *
 * <ul>
 * <li>Invoke {@code method} on the result of {@code createTest()}, and
 * throw any exceptions thrown by either operation.
 * <li>HOWEVER, if {@code method}'s {@code @Test} annotation has the {@code
 * expecting} attribute, return normally only if the previous step threw an
 * exception of the correct type, and throw an exception otherwise.
 * <li>HOWEVER, if {@code method}'s {@code @Test} annotation has the {@code
 * timeout} attribute, throw an exception if the previous step takes more
 * than the specified number of milliseconds.
 * <li>ALWAYS run all non-overridden {@code @Before} methods on this class
 * and superclasses before any of the previous steps; if any throws an
 * Exception, stop execution and pass the exception on.
 * <li>ALWAYS run all non-overridden {@code @After} methods on this class
 * and superclasses after any of the previous steps; all After methods are
 * always executed: exceptions thrown by previous steps are combined, if
 * necessary, with exceptions from After methods into a
 * {@link org.junit.runners.model.MultipleFailureException}.
 * <li>ALWAYS allow {@code @Rule} fields to modify the execution of the
 * above steps. A {@code Rule} may prevent all execution of the above steps,
 * or add additional behavior before and after, or modify thrown exceptions.
 * For more information, see {@link org.junit.rules.TestRule}
 * </ul>
 *
 * This can be overridden in subclasses, either by overriding this method,
 * or the implementations creating each sub-statement.
 */
protected Statement methodBlock(FrameworkMethod method) {
    Object test;
    try {
        test = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest();
            }
        }.run();
    } catch (Throwable e) {
        return new Fail(e);
    }

    Statement statement = methodInvoker(method, test);
    statement = possiblyExpectingExceptions(method, test, statement);
    statement = withPotentialTimeout(method, test, statement);
    statement = withBefores(method, test, statement);
    statement = withAfters(method, test, statement);
    statement = withRules(method, test, statement);
    return statement;
}
 

/**
 * Augment the default JUnit behavior
 * {@linkplain #withPotentialRepeat with potential repeats} of the entire
 * execution chain.
 * <p>Furthermore, support for timeouts has been moved down the execution
 * chain in order to include execution of {@link org.junit.Before @Before}
 * and {@link org.junit.After @After} methods within the timed execution.
 * Note that this differs from the default JUnit behavior of executing
 * {@code @Before} and {@code @After} methods in the main thread while
 * executing the actual test method in a separate thread. Thus, the net
 * effect is that {@code @Before} and {@code @After} methods will be
 * executed in the same thread as the test method. As a consequence,
 * JUnit-specified timeouts will work fine in combination with Spring
 * transactions. However, JUnit-specific timeouts still differ from
 * Spring-specific timeouts in that the former execute in a separate
 * thread while the latter simply execute in the main thread (like regular
 * tests).
 * @see #methodInvoker(FrameworkMethod, Object)
 * @see #withBeforeTestExecutionCallbacks(FrameworkMethod, Object, Statement)
 * @see #withAfterTestExecutionCallbacks(FrameworkMethod, Object, Statement)
 * @see #possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
 * @see #withBefores(FrameworkMethod, Object, Statement)
 * @see #withAfters(FrameworkMethod, Object, Statement)
 * @see #withRulesReflectively(FrameworkMethod, Object, Statement)
 * @see #withPotentialRepeat(FrameworkMethod, Object, Statement)
 * @see #withPotentialTimeout(FrameworkMethod, Object, Statement)
 */
@Override
protected Statement methodBlock(FrameworkMethod frameworkMethod) {
	Object testInstance;
	try {
		testInstance = new ReflectiveCallable() {
			@Override
			protected Object runReflectiveCall() throws Throwable {
				return createTest();
			}
		}.run();
	}
	catch (Throwable ex) {
		return new Fail(ex);
	}

	Statement statement = methodInvoker(frameworkMethod, testInstance);
	statement = withBeforeTestExecutionCallbacks(frameworkMethod, testInstance, statement);
	statement = withAfterTestExecutionCallbacks(frameworkMethod, testInstance, statement);
	statement = possiblyExpectingExceptions(frameworkMethod, testInstance, statement);
	statement = withBefores(frameworkMethod, testInstance, statement);
	statement = withAfters(frameworkMethod, testInstance, statement);
	statement = withRulesReflectively(frameworkMethod, testInstance, statement);
	statement = withPotentialRepeat(frameworkMethod, testInstance, statement);
	statement = withPotentialTimeout(frameworkMethod, testInstance, statement);
	return statement;
}
 

/**
 * Augment the default JUnit behavior
 * {@linkplain #withPotentialRepeat with potential repeats} of the entire
 * execution chain.
 * <p>Furthermore, support for timeouts has been moved down the execution
 * chain in order to include execution of {@link org.junit.Before @Before}
 * and {@link org.junit.After @After} methods within the timed execution.
 * Note that this differs from the default JUnit behavior of executing
 * {@code @Before} and {@code @After} methods in the main thread while
 * executing the actual test method in a separate thread. Thus, the net
 * effect is that {@code @Before} and {@code @After} methods will be
 * executed in the same thread as the test method. As a consequence,
 * JUnit-specified timeouts will work fine in combination with Spring
 * transactions. However, JUnit-specific timeouts still differ from
 * Spring-specific timeouts in that the former execute in a separate
 * thread while the latter simply execute in the main thread (like regular
 * tests).
 * @see #methodInvoker(FrameworkMethod, Object)
 * @see #withBeforeTestExecutionCallbacks(FrameworkMethod, Object, Statement)
 * @see #withAfterTestExecutionCallbacks(FrameworkMethod, Object, Statement)
 * @see #possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
 * @see #withBefores(FrameworkMethod, Object, Statement)
 * @see #withAfters(FrameworkMethod, Object, Statement)
 * @see #withRulesReflectively(FrameworkMethod, Object, Statement)
 * @see #withPotentialRepeat(FrameworkMethod, Object, Statement)
 * @see #withPotentialTimeout(FrameworkMethod, Object, Statement)
 */
@Override
protected Statement methodBlock(FrameworkMethod frameworkMethod) {
	Object testInstance;
	try {
		testInstance = new ReflectiveCallable() {
			@Override
			protected Object runReflectiveCall() throws Throwable {
				return createTest();
			}
		}.run();
	}
	catch (Throwable ex) {
		return new Fail(ex);
	}

	Statement statement = methodInvoker(frameworkMethod, testInstance);
	statement = withBeforeTestExecutionCallbacks(frameworkMethod, testInstance, statement);
	statement = withAfterTestExecutionCallbacks(frameworkMethod, testInstance, statement);
	statement = possiblyExpectingExceptions(frameworkMethod, testInstance, statement);
	statement = withBefores(frameworkMethod, testInstance, statement);
	statement = withAfters(frameworkMethod, testInstance, statement);
	statement = withRulesReflectively(frameworkMethod, testInstance, statement);
	statement = withPotentialRepeat(frameworkMethod, testInstance, statement);
	statement = withPotentialTimeout(frameworkMethod, testInstance, statement);
	return statement;
}