package org.junit.tests.running.methods;
   
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertTrue;
   
   import java.util.Collections;
   import java.util.List;
   
   import junit.framework.JUnit4TestAdapter;
  import junit.framework.TestResult;
  import org.junit.After;
  import org.junit.AfterClass;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import org.junit.Ignore;
  import org.junit.Test;
  import org.junit.runner.JUnitCore;
  import org.junit.runner.Result;
  import org.junit.runners.BlockJUnit4ClassRunner;
  import org.junit.runners.model.InitializationError;
  
  public class TestMethodTest {
  
      @SuppressWarnings("all")
      public static class EverythingWrong {
          private EverythingWrong() {
          }
  
          @BeforeClass
          public void notStaticBC() {
          }
  
          @BeforeClass
          static void notPublicBC() {
          }
  
          @BeforeClass
          public static int nonVoidBC() {
              return 0;
          }
  
          @BeforeClass
          public static void argumentsBC(int i) {
          }
  
          @BeforeClass
          public static void fineBC() {
          }
  
          @AfterClass
          public void notStaticAC() {
          }
  
          @AfterClass
          static void notPublicAC() {
          }
  
          @AfterClass
          public static int nonVoidAC() {
              return 0;
          }
  
          @AfterClass
          public static void argumentsAC(int i) {
          }
  
          @AfterClass
          public static void fineAC() {
          }
  
          @After
          public static void staticA() {
          }
  
          @After
          void notPublicA() {
          }
  
          @After
          public int nonVoidA() {
              return 0;
          }
  
          @After
          public void argumentsA(int i) {
          }
  
          @After
          public void fineA() {
          }
  
          @Before
          public static void staticB() {
          }
  
          @Before
          void notPublicB() {
          }
  
         @Before
         public int nonVoidB() {
             return 0;
         }
 
         @Before
         public void argumentsB(int i) {
         }
 
         @Before
         public void fineB() {
         }
 
         @Test
         public static void staticT() {
         }
 
         @Test
         void notPublicT() {
         }
 
         @Test
         public int nonVoidT() {
             return 0;
         }
 
         @Test
         public void argumentsT(int i) {
         }
 
         @Test
         public void fineT() {
         }
     }
 
     @Test
     public void testFailures() throws Exception {
         List<Throwable> problems = validateAllMethods(EverythingWrong.class);
         int errorCount = 1 + 4 * 5; // missing constructor plus four invalid methods for each annotation */
         assertEquals(errorCount, problems.size());
     }
 
     static public class SuperWrong {
         @Test
         void notPublic() {
         }
     }
 
     static public class SubWrong extends SuperWrong {
         @Test
         public void justFine() {
         }
     }
 
     @Test
     public void validateInheritedMethods() throws Exception {
         List<Throwable> problems = validateAllMethods(SubWrong.class);
         assertEquals(1, problems.size());
     }
 
     static public class SubShadows extends SuperWrong {
         @Override
         @Test
         public void notPublic() {
         }
     }
 
     @Test
     public void dontValidateShadowedMethods() throws Exception {
         List<Throwable> problems = validateAllMethods(SubShadows.class);
         assertTrue(problems.isEmpty());
     }
 
     private List<Throwable> validateAllMethods(Class<?> clazz) {
         try {
             new BlockJUnit4ClassRunner(clazz);
         } catch (InitializationError e) {
             return e.getCauses();
         }
         return Collections.emptyList();
     }
 
     static public class IgnoredTest {
         @Test
         public void valid() {
         }
 
         @Ignore
         @Test
         public void ignored() {
         }
 
         @Ignore("For testing purposes")
         @Test
         public void withReason() {
         }
     }
 
     @Test
     public void ignoreRunner() {
         JUnitCore runner = new JUnitCore();
         Result result = runner.run(IgnoredTest.class);
         assertEquals(2, result.getIgnoreCount());
         assertEquals(1, result.getRunCount());
     }
 
     @Test
     public void compatibility() {
         TestResult result = new TestResult();
         new JUnit4TestAdapter(IgnoredTest.class).run(result);
         assertEquals(1, result.runCount());
     }
 
     public static class Confused {
         @Test
         public void a(Object b) {
         }
 
         @Test
         public void a() {
         }
     }
 
     @Test(expected = InitializationError.class)
     public void overloaded() throws InitializationError {
         new BlockJUnit4ClassRunner(Confused.class);
     }
 
     public static class ConstructorParameter {
         public ConstructorParameter(Object something) {
         }
 
         @Test
         public void a() {
         }
     }
 
     @Test(expected = InitializationError.class)
     public void constructorParameter() throws InitializationError {
         new BlockJUnit4ClassRunner(ConstructorParameter.class);
     }
 
     public static class OnlyTestIsIgnored {
         @Ignore
         @Test
         public void ignored() {
         }
     }
 
     @Test
     public void onlyIgnoredMethodsIsStillFineTestClass() {
         Result result = JUnitCore.runClasses(OnlyTestIsIgnored.class);
         assertEquals(0, result.getFailureCount());
         assertEquals(1, result.getIgnoreCount());
     }
 }