View Javadoc
1   package org.junit.tests.experimental.rules;
2   
3   import static org.hamcrest.CoreMatchers.containsString;
4   import static org.hamcrest.CoreMatchers.is;
5   import static org.junit.Assert.assertEquals;
6   import static org.junit.Assert.assertThat;
7   import static org.junit.Assert.assertTrue;
8   import static org.junit.Assert.fail;
9   import static org.junit.experimental.results.PrintableResult.testResult;
10  import static org.junit.experimental.results.ResultMatchers.hasSingleFailureContaining;
11  import static org.junit.experimental.results.ResultMatchers.isSuccessful;
12  import org.junit.After;
13  import org.junit.Before;
14  import org.junit.Rule;
15  import org.junit.Test;
16  import org.junit.rules.MethodRule;
17  import org.junit.rules.TestName;
18  import org.junit.rules.TestRule;
19  import org.junit.rules.TestWatchman;
20  import org.junit.runner.Description;
21  import org.junit.runner.JUnitCore;
22  import org.junit.runner.Result;
23  import org.junit.runners.model.FrameworkMethod;
24  import org.junit.runners.model.Statement;
25  
26  @SuppressWarnings("deprecation")
27  public class MethodRulesTest {
28      private static boolean wasRun;
29  
30      public static class ExampleTest {
31          @Rule
32          public MethodRule example = new MethodRule() {
33              public Statement apply(final Statement base,
34                      FrameworkMethod method, Object target) {
35                  return new Statement() {
36                      @Override
37                      public void evaluate() throws Throwable {
38                          wasRun = true;
39                          base.evaluate();
40                      }
41  
42                      ;
43                  };
44              }
45          };
46  
47          @Test
48          public void nothing() {
49  
50          }
51      }
52  
53      @Test
54      public void ruleIsIntroducedAndEvaluated() {
55          wasRun = false;
56          JUnitCore.runClasses(ExampleTest.class);
57          assertTrue(wasRun);
58      }
59  
60      public static class SonOfExampleTest extends ExampleTest {
61  
62      }
63  
64      @Test
65      public void ruleIsIntroducedAndEvaluatedOnSubclass() {
66          wasRun = false;
67          JUnitCore.runClasses(SonOfExampleTest.class);
68          assertTrue(wasRun);
69      }
70  
71      private static int runCount;
72  
73      public static class MultipleRuleTest {
74          private static class Increment implements MethodRule {
75              public Statement apply(final Statement base,
76                      FrameworkMethod method, Object target) {
77                  return new Statement() {
78                      @Override
79                      public void evaluate() throws Throwable {
80                          runCount++;
81                          base.evaluate();
82                      }
83  
84                      ;
85                  };
86              }
87          }
88  
89          @Rule
90          public MethodRule incrementor1 = new Increment();
91  
92          @Rule
93          public MethodRule incrementor2 = new Increment();
94  
95          @Test
96          public void nothing() {
97  
98          }
99      }
100 
101     @Test
102     public void multipleRulesAreRun() {
103         runCount = 0;
104         JUnitCore.runClasses(MultipleRuleTest.class);
105         assertEquals(2, runCount);
106     }
107 
108     public static class NoRulesTest {
109         public int x;
110 
111         @Test
112         public void nothing() {
113 
114         }
115     }
116 
117     @Test
118     public void ignoreNonRules() {
119         Result result = JUnitCore.runClasses(NoRulesTest.class);
120         assertEquals(0, result.getFailureCount());
121     }
122 
123     private static String log;
124 
125     public static class OnFailureTest {
126         @Rule
127         public MethodRule watchman = new TestWatchman() {
128             @Override
129             public void failed(Throwable e, FrameworkMethod method) {
130                 log += method.getName() + " " + e.getClass().getSimpleName();
131             }
132         };
133 
134         @Test
135         public void nothing() {
136             fail();
137         }
138     }
139 
140     @Test
141     public void onFailure() {
142         log = "";
143         Result result = JUnitCore.runClasses(OnFailureTest.class);
144         assertEquals("nothing AssertionError", log);
145         assertEquals(1, result.getFailureCount());
146     }
147 
148     public static class WatchmanTest {
149         private static String watchedLog;
150 
151         @Rule
152         public MethodRule watchman = new TestWatchman() {
153             @Override
154             public void failed(Throwable e, FrameworkMethod method) {
155                 watchedLog += method.getName() + " "
156                         + e.getClass().getSimpleName() + "\n";
157             }
158 
159             @Override
160             public void succeeded(FrameworkMethod method) {
161                 watchedLog += method.getName() + " " + "success!\n";
162             }
163         };
164 
165         @Test
166         public void fails() {
167             fail();
168         }
169 
170         @Test
171         public void succeeds() {
172         }
173     }
174 
175     @Test
176     public void succeeded() {
177         WatchmanTest.watchedLog = "";
178         JUnitCore.runClasses(WatchmanTest.class);
179         assertThat(WatchmanTest.watchedLog, containsString("fails AssertionError"));
180         assertThat(WatchmanTest.watchedLog, containsString("succeeds success!"));
181     }
182 
183     public static class BeforesAndAfters {
184         private static String watchedLog;
185 
186         @Before
187         public void before() {
188             watchedLog += "before ";
189         }
190 
191         @Rule
192         public MethodRule watchman = new TestWatchman() {
193             @Override
194             public void starting(FrameworkMethod method) {
195                 watchedLog += "starting ";
196             }
197 
198             @Override
199             public void finished(FrameworkMethod method) {
200                 watchedLog += "finished ";
201             }
202 
203             @Override
204             public void succeeded(FrameworkMethod method) {
205                 watchedLog += "succeeded ";
206             }
207         };
208 
209         @After
210         public void after() {
211             watchedLog += "after ";
212         }
213 
214         @Test
215         public void succeeds() {
216             watchedLog += "test ";
217         }
218     }
219 
220     @Test
221     public void beforesAndAfters() {
222         BeforesAndAfters.watchedLog = "";
223         JUnitCore.runClasses(BeforesAndAfters.class);
224         assertThat(BeforesAndAfters.watchedLog, is("starting before test after succeeded finished "));
225     }
226 
227     public static class WrongTypedField {
228         @Rule
229         public int x = 5;
230 
231         @Test
232         public void foo() {
233         }
234     }
235 
236     @Test
237     public void validateWrongTypedField() {
238         assertThat(testResult(WrongTypedField.class),
239                 hasSingleFailureContaining("must implement MethodRule"));
240     }
241 
242     public static class SonOfWrongTypedField extends WrongTypedField {
243 
244     }
245 
246     @Test
247     public void validateWrongTypedFieldInSuperclass() {
248         assertThat(testResult(SonOfWrongTypedField.class),
249                 hasSingleFailureContaining("must implement MethodRule"));
250     }
251 
252     public static class PrivateRule {
253         @Rule
254         private TestRule rule = new TestName();
255 
256         @Test
257         public void foo() {
258         }
259     }
260 
261     @Test
262     public void validatePrivateRule() {
263         assertThat(testResult(PrivateRule.class),
264                 hasSingleFailureContaining("must be public"));
265     }
266 
267     public static class CustomTestName implements TestRule {
268         public String name = null;
269 
270         public Statement apply(final Statement base, final Description description) {
271             return new Statement() {
272                 @Override
273                 public void evaluate() throws Throwable {
274                     name = description.getMethodName();
275                     base.evaluate();
276                 }
277             };
278         }
279     }
280 
281     public static class UsesCustomMethodRule {
282         @Rule
283         public CustomTestName counter = new CustomTestName();
284 
285         @Test
286         public void foo() {
287             assertEquals("foo", counter.name);
288         }
289     }
290 
291     @Test
292     public void useCustomMethodRule() {
293         assertThat(testResult(UsesCustomMethodRule.class), isSuccessful());
294     }
295 }