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

org.junit.experimental.theories

## Class Theories

- java.lang.Object
- - org.junit.runner.Runner
  - - org.junit.runners.ParentRunner<FrameworkMethod>
    - - org.junit.runners.BlockJUnit4ClassRunner
      - - org.junit.experimental.theories.Theories

- All Implemented Interfaces:
    Describable, Filterable, Sortable

      public class Theories
      extends BlockJUnit4ClassRunner

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Theories.TheoryAnchor`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Theories(Class<?> klass)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `collectInitializationErrors(List<Throwable> errors)` Adds to `errors` a throwable for each problem noted with the test class (available from `ParentRunner.getTestClass()`).
    `protected List<FrameworkMethod>` | `computeTestMethods()` Returns the methods that run tests.
    `Statement` | `methodBlock(FrameworkMethod method)` Returns a Statement that, when executed, either returns normally if `method` passes, or throws an exception if `method` fails.
    `protected void` | `validateConstructor(List<Throwable> errors)` Adds to `errors` if the test class has more than one constructor, or if the constructor takes parameters.
    `protected void` | `validateTestMethods(List<Throwable> errors)` Adds to `errors` for each method annotated with `@Test`that is not a public, void instance method with no arguments.

    - ### Methods inherited from class org.junit.runners.BlockJUnit4ClassRunner

      `createTest, describeChild, getChildren, getTestRules, methodInvoker, possiblyExpectingExceptions, rules, runChild, testName, validateFields, validateInstanceMethods, validateNoNonStaticInnerClass, validateOnlyOneConstructor, validateZeroArgConstructor, withAfters, withBefores, withPotentialTimeout`

    - ### Methods inherited from class org.junit.runners.ParentRunner

      `childrenInvoker, classBlock, classRules, filter, getDescription, getName, getRunnerAnnotations, getTestClass, run, runLeaf, setScheduler, sort, validatePublicVoidNoArgMethods, withAfterClasses, withBeforeClasses`

    - ### Methods inherited from class org.junit.runner.Runner

      `testCount`

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

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

- - ### Constructor Detail

    - #### Theories

          public Theories(Class<?> klass)
                   throws InitializationError

      Throws:
        `InitializationError`

  - ### Method Detail

    - #### collectInitializationErrors

          protected void collectInitializationErrors(List<Throwable> errors)

      Description copied from class: `ParentRunner`
      Adds to `errors` a throwable for each problem noted with the test class (available from `ParentRunner.getTestClass()`). Default implementation adds an error for each method annotated with `@BeforeClass` or `@AfterClass` that is not `public static void` with no arguments.
      Overrides:
        `collectInitializationErrors` in class `BlockJUnit4ClassRunner`

    - #### validateConstructor

          protected void validateConstructor(List<Throwable> errors)

      Description copied from class: `BlockJUnit4ClassRunner`
      Adds to `errors` if the test class has more than one constructor, or if the constructor takes parameters. Override if a subclass requires different validation rules.
      Overrides:
        `validateConstructor` in class `BlockJUnit4ClassRunner`

    - #### validateTestMethods

          protected void validateTestMethods(List<Throwable> errors)

      Description copied from class: `BlockJUnit4ClassRunner`
      Adds to `errors` for each method annotated with `@Test`that is not a public, void instance method with no arguments.
      Overrides:
        `validateTestMethods` in class `BlockJUnit4ClassRunner`

    - #### computeTestMethods

          protected List<FrameworkMethod> computeTestMethods()

      Description copied from class: `BlockJUnit4ClassRunner`
      Returns the methods that run tests. Default implementation returns all methods annotated with `@Test` on this class and superclasses that are not overridden.
      Overrides:
        `computeTestMethods` in class `BlockJUnit4ClassRunner`

    - #### methodBlock

          public Statement methodBlock(FrameworkMethod method)

      Description copied from class: `BlockJUnit4ClassRunner`
      Returns a Statement that, when executed, either returns normally if `method` passes, or throws an exception if `method` fails. Here is an outline of the default implementation:
      - Invoke `method` on the result of `createTest()`, and throw any exceptions thrown by either operation.
      - HOWEVER, if `method`'s `@Test` annotation has the `expecting` attribute, return normally only if the previous step threw an exception of the correct type, and throw an exception otherwise.
      - HOWEVER, if `method`'s `@Test` annotation has the `timeout` attribute, throw an exception if the previous step takes more than the specified number of milliseconds.
      - ALWAYS run all non-overridden `@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.
      - ALWAYS run all non-overridden `@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 `MultipleFailureException`.
      - ALWAYS allow `@Rule` fields to modify the execution of the above steps. A `Rule` may prevent all execution of the above steps, or add additional behavior before and after, or modify thrown exceptions. For more information, see `TestRule`
      This can be overridden in subclasses, either by overriding this method, or the implementations creating each sub-statement.
      Overrides:
        `methodBlock` in class `BlockJUnit4ClassRunner`