org.junit.runners.model.Statement#evaluate()源码实例Demo

public Statement apply(final Statement base, FrameworkMethod method, Object target) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            originalStdOut = System.out;
            originalStdErr = System.err;
            try {
                System.setOut(stdOutPrintStream);
                System.setErr(stdErrPrintStream);
                base.evaluate();
            } finally {
                System.setOut(originalStdOut);
                System.setErr(originalStdErr);
                stdOutPrintStream = null;
                stdErrPrintStream = null;
                stdoutContent = null;
                stderrContent = null;
            }
        }
    };
}
 

private Statement statement(final Statement base, final Description description) {
  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      String testName = description.getMethodName();
      int i = 1;
      do {
        printData(
            "************* RUNNING Test: %s Iteration: %d *************", null, testName, i);
        try {
          base.evaluate();
          printData(
              "************* PASS Test: %s Iteration: %d  **************", null, testName, i);
          return;
        } catch (Throwable t) {
          performPostFailureActions(testName, i, t);
          if (i == retryCount) {
            throw t;
          }
        }
        i += 1;
      } while (i < retryCount);
    }
  };
}
 

@Override
public Statement apply(final Statement base, Description description) {
  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      Throwable caughtThrowable = null;

      for (int i = 0; i < retryCount; i++) {
        try {
          base.evaluate();
          return;
        } catch (Throwable t) {
          caughtThrowable = t;
        }
      }

      throw caughtThrowable;
    }
  };
}
 

/**
 * {@inheritDoc}
 */
@Override
public Statement apply(final Statement base, final Description description) {
    wrapSystemErr();

    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            try {
                base.evaluate();
                verifyNoOutput();
            }
            finally {
                restoreSystemErr();
            }
        }
    };
}
 

/**
 * Implementation based on {@link TestWatcher}.
 */
@Override
public Statement apply(final Statement base, final Description description) {
  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      List<Throwable> errors = new ArrayList<Throwable>();

      startingQuietly(description, errors);
      try {
        base.evaluate();
        succeededQuietly(description, errors);
      } catch (AssumptionViolatedException e) {
        errors.add(e);
        skippedQuietly(e, description, errors);
      } catch (Throwable t) {
        errors.add(t);
        failedQuietly(t, description, errors);
      } finally {
        finishedQuietly(description, errors);
      }

      MultipleFailureException.assertEmpty(errors);
    }
  };
}
 

@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            RxJavaPlugins.setIoSchedulerHandler(scheduler -> mTestScheduler);
            RxJavaPlugins.setComputationSchedulerHandler(scheduler -> mTestScheduler);
            RxJavaPlugins.setNewThreadSchedulerHandler(scheduler -> mTestScheduler);
            RxAndroidPlugins.setMainThreadSchedulerHandler(scheduler -> mTestScheduler);

            try {
                base.evaluate();
            } finally {
                RxJavaPlugins.reset();
                RxAndroidPlugins.reset();
            }
        }
    };
}
 

@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            try {
                if (mLocales != null) {
                    mDeviceLocale = Locale.getDefault();
                    for (Locale locale : mLocales) {
                        setLocale(locale);
                        base.evaluate();
                    }
                }
            } finally {
                if (mDeviceLocale != null) {
                    setLocale(mDeviceLocale);
                }
            }
        }
    };
}
 

/**
 * Implementation based on {@link TestWatcher}.
 */
@Override
public Statement apply(final Statement base, final Description description) {
	return new Statement() {
		@Override
		public void evaluate() throws Throwable {
			List<Throwable> errors = new ArrayList<Throwable>();

			startingQuietly(description, errors);
			try {
				base.evaluate();
				succeededQuietly(description, errors);
			} catch (AssumptionViolatedException e) {
				errors.add(e);
				skippedQuietly(e, description, errors);
			} catch (Throwable t) {
				errors.add(t);
				failedQuietly(t, description, errors);
			} finally {
				finishedQuietly(description, errors);
			}

			MultipleFailureException.assertEmpty(errors);
		}
	};
}
 

@Override
public Statement apply(final Statement base, Description description) {
  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      server.start();
      base.evaluate();
      server.shutdown();
    }
  };
}
 

@Override
public Statement apply(final Statement base, final Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            TestTopologyRule.this.start();
            try {
                base.evaluate();
            } finally {
                TestTopologyRule.this.stop();
            }
        }
    };
}
 

@Override
public Statement apply(final Statement base, Description description) {
  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      resetState();
      try {
        base.evaluate();
      } finally {
        resetState();
      }
    }
  };
}
 

public Statement apply(final Statement base, FrameworkMethod method, Object target) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            originalStdIn = System.in;
            try {
                base.evaluate();
            } finally {
                System.setIn(originalStdIn);
                originalStdIn = null;
            }
        }
    };
}
 

@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            RxJavaPlugins.reset();
            RxJavaPlugins.setIoSchedulerHandler(scheduler -> Schedulers.trampoline());
            RxAndroidPlugins.reset();
            RxAndroidPlugins.setMainThreadSchedulerHandler(scheduler -> Schedulers.trampoline());
            base.evaluate();
        }
    };
}
 

public Statement apply(final Statement base, FrameworkMethod method, Object target) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            originalStdIn = System.in;
            try {
                base.evaluate();
            } finally {
                System.setIn(originalStdIn);
                originalStdIn = null;
            }
        }
    };
}
 

@Override
public Statement apply(Statement base, FrameworkMethod method, Object target) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            try (KafkaServerScope scope = new KafkaServerScope(requiresKafkaServer(method))) {
                base.evaluate();
            }
        }
    };
}
 

@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @SuppressWarnings("unchecked")
        @Override
        public void evaluate() throws Throwable {
            resetSubscriberMock();
            base.evaluate();
        }
    };
}
 

@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            RxJavaPlugins.reset();
            RxJavaPlugins.setIoSchedulerHandler(scheduler -> Schedulers.trampoline());
            RxAndroidPlugins.reset();
            RxAndroidPlugins.setMainThreadSchedulerHandler(scheduler -> Schedulers.trampoline());
            base.evaluate();
        }
    };
}
 

@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            if (dbEngine == DatabaseEngine.POSTGRES) {
                base.evaluate();
            } else {
                throw new AssumptionViolatedException(
                        "Current database engine is " + dbEngine.toString() +
                        ", test requires POSTGRES. Skipping");
            }
        }
    };
}
 

public Statement apply(final Statement base, Description description) {
    init(description.getMethodName(), description.getTestClass().getSimpleName());
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            base.evaluate();
            getTestDirectory().maybeDeleteDir();
            // Don't delete on failure
        }
    };
}
 

private void ignoreStatementExecution(Statement base) {
    try {
        base.evaluate();
    } catch (Throwable ignored) {}
}