RuleChain (JUnit API)
Date: 2016-08-24

org.junit.rules

## Class RuleChain

- java.lang.Object
- - org.junit.rules.RuleChain

- All Implemented Interfaces:
    TestRule

      public class RuleChain
      extends Object
      implements TestRule

  The RuleChain rule allows ordering of TestRules. You create a `RuleChain` with `outerRule(TestRule)` and subsequent calls of `around(TestRule)`:

       public static class UseRuleChain {
              @Rule
              public RuleChain chain= RuleChain
                                     .outerRule(new LoggingRule("outer rule")
                                     .around(new LoggingRule("middle rule")
                                     .around(new LoggingRule("inner rule");

              @Test
              public void example() {
                      assertTrue(true);
           }
       }

  writes the log

       starting outer rule
       starting middle rule
       starting inner rule
       finished inner rule
       finished middle rule
       finished outer rule

  Since:
    4.10

- - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Statement` | `apply(Statement base, Description description)` Modifies the method-running `Statement` to implement this test-running rule.
    `RuleChain` | `around(TestRule enclosedRule)` Create a new `RuleChain`, which encloses the `nextRule` with the rules of the current `RuleChain`.
    `static RuleChain` | `emptyRuleChain()` Returns a `RuleChain` without a `TestRule`.
    `static RuleChain` | `outerRule(TestRule outerRule)` Returns a `RuleChain` with a single `TestRule`.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### emptyRuleChain

          public static RuleChain emptyRuleChain()

      Returns a `RuleChain` without a `TestRule`. This method may be the starting point of a `RuleChain`.
      Returns:
        a `RuleChain` without a `TestRule`.

    - #### outerRule

          public static RuleChain outerRule(TestRule outerRule)

      Returns a `RuleChain` with a single `TestRule`. This method is the usual starting point of a `RuleChain`.
      Parameters:
        `outerRule` - the outer rule of the `RuleChain`.
      Returns:
        a `RuleChain` with a single `TestRule`.

    - #### around

          public RuleChain around(TestRule enclosedRule)

      Create a new `RuleChain`, which encloses the `nextRule` with the rules of the current `RuleChain`.
      Parameters:
        `enclosedRule` - the rule to enclose.
      Returns:
        a new `RuleChain`.

    - #### apply

          public Statement apply(Statement base,
                                 Description description)

      Modifies the method-running `Statement` to implement this test-running rule.
      Specified by:
        `apply` in interface `TestRule`
      Parameters:
        `base` - The `Statement` to be modified
        `description` - A `Description` of the test implemented in `base`
      Returns:
        a new statement, which may be the same as `base`, a wrapper around `base`, or a completely new Statement.