code: @RuntimeType
      public static Object intercept(@This final Object callable, @SuperCall final Callable<?> proxy)
                      throws Exception {
          
          Object runner = null;
          Object target = null;
          FrameworkMethod method = null;
          Object[] params = null;
  
          try {
              Object owner = getFieldValue(callable, "this$0");
              if (owner instanceof FrameworkMethod) {
                  method = (FrameworkMethod) owner;
                  target = getFieldValue(callable, "val$target");
                  params = getFieldValue(callable, "val$params");
                  
                  if (isParticleMethod(method)) {
                      if (target != null) {
                          runner = CreateTest.getRunnerForTarget(target);
                      } else {
                          runner = Run.getThreadRunner();
                      }
                  }
              } else {
                  runner = owner;
              }
          } catch (IllegalAccessException | NoSuchFieldException | SecurityException | IllegalArgumentException e) {
              // handled below
          }
          
          if (method == null) {
              return LifecycleHooks.callProxy(proxy);
          }
          
          Object result = null;
          Throwable thrown = null;
  
          try {
              fireBeforeInvocation(runner, target, method, params);
              result = LifecycleHooks.callProxy(proxy);
          } catch (Throwable t) {
              thrown = t;
          } finally {
              fireAfterInvocation(runner, target, method, thrown);
          }
  
          if (thrown != null) {
              throw UncheckedThrow.throwUnchecked(thrown);
          }
  
          return result;
      }
docs: Interceptor for the {@link org.junit.internal.runners.model.ReflectiveCallable#runReflectiveCall
  runReflectiveCall} method.
  
  @param callable {@code ReflectiveCallable} object being intercepted
  @param proxy callable proxy for the intercepted method
  @return {@code anything} - value returned by the intercepted method
  @throws Exception {@code anything} (exception thrown by the intercepted method)