## org.junit
Annotation Type ClassRule

    @Retention(value=RUNTIME)
    @Target(value={FIELD,METHOD})
    public @interface ClassRule

Annotates static fields that reference rules or methods that return them. A field must be public, static, and a subtype of `TestRule`. A method must be public static, and return a subtype of `TestRule`.

The `Statement` passed to the `TestRule` will run any `BeforeClass` methods, then the entire body of the test class (all contained methods, if it is a standard JUnit test class, or all contained classes, if it is a `Suite`), and finally any `AfterClass` methods.

The statement passed to the `TestRule` will never throw an exception, and throwing an exception from the `TestRule` will result in undefined behavior. This means that some `TestRule`s, such as `ErrorCollector`, `ExpectedException`, and `Timeout`, have undefined behavior when used as `ClassRule`s.

If there are multiple annotated `ClassRule`s on a class, they will be applied in an order that depends on your JVM's implementation of the reflection API, which is undefined, in general. However, Rules defined by fields will always be applied after Rules defined by methods, i.e. the Statements returned by the former will be executed around those returned by the latter.

### Usage

For example, here is a test suite that connects to a server once before all the test classes run, and disconnects after they are finished:

     @RunWith(Suite.class)
     @SuiteClasses({A.class, B.class, C.class})
     public class UsesExternalResource {
         public static Server myServer= new Server();

         @ClassRule
         public static ExternalResource resource= new ExternalResource() {
           @Override
           protected void before() throws Throwable {
              myServer.connect();
          }

          @Override
          protected void after() {
                    myServer.disconnect();
          }
       };
     }

and the same using a method

     @RunWith(Suite.class)
     @SuiteClasses({A.class, B.class, C.class})
     public class UsesExternalResource {
         public static Server myServer= new Server();

         @ClassRule
         public static ExternalResource getResource() {
             return new ExternalResource() {
                 @Override
                 protected void before() throws Throwable {
                     myServer.connect();
                 }

                 @Override
                 protected void after() {
                     myServer.disconnect();
                 }
             };
         }
     }

For more information and more examples, see `TestRule`.

### Ordering

You can use `order()` if you want to have control over the order in which the Rules are applied.

     public class ThreeClassRules {
         @ClassRule(order = 0)
         public static LoggingRule outer = new LoggingRule("outer rule");

         @ClassRule(order = 1)
         public static LoggingRule middle = new LoggingRule("middle rule");

         @ClassRule(order = 2)
         public static LoggingRule inner = new LoggingRule("inner rule");

         // ...
     }

Since:
  4.9

Optional Element Summary
`int` `order` Specifies the order in which rules are applied.

### order

    public abstract int order

  Specifies the order in which rules are applied. The rules with a higher value are inner.

  Since:
    4.13
  Default:
    -1

Copyright © 2002–2020 JUnit. All rights reserved.