package org.junit.tests.running.methods;
   
   import static org.hamcrest.CoreMatchers.allOf;
   import static org.hamcrest.CoreMatchers.containsString;
   import static org.junit.Assert.assertThat;
   
   import java.util.Collection;
   import java.util.HashSet;
   
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import org.junit.After;
  import org.junit.AfterClass;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import org.junit.Test;
  import org.junit.runner.Description;
  import org.junit.runner.JUnitCore;
  import org.junit.runner.Result;
  import org.junit.runner.RunWith;
  import org.junit.runners.JUnit4;
  
  public class AnnotationTest extends TestCase {
      static boolean run;
  
      @Override
      public void setUp() {
          run = false;
      }
  
      static public class SimpleTest {
          @Test
          public void success() {
              run = true;
          }
      }
  
      public void testAnnotatedMethod() throws Exception {
          JUnitCore runner = new JUnitCore();
          runner.run(SimpleTest.class);
          assertTrue(run);
      }
  
      @RunWith(JUnit4.class)
      static public class SimpleTestWithFutureProofExplicitRunner {
          @Test
          public void success() {
              run = true;
          }
      }
  
      public void testAnnotatedMethodWithFutureProofExplicitRunner() throws Exception {
          JUnitCore runner = new JUnitCore();
          runner.run(SimpleTestWithFutureProofExplicitRunner.class);
          assertTrue(run);
      }
  
      static public class SetupTest {
          @Before
          public void before() {
              run = true;
          }
  
          @Test
          public void success() {
          }
      }
  
      public void testSetup() throws Exception {
          JUnitCore runner = new JUnitCore();
          runner.run(SetupTest.class);
          assertTrue(run);
      }
  
      static public class TeardownTest {
          @After
          public void after() {
              run = true;
          }
  
          @Test
          public void success() {
          }
      }
  
      public void testTeardown() throws Exception {
          JUnitCore runner = new JUnitCore();
          runner.run(TeardownTest.class);
          assertTrue(run);
      }
  
      static public class FailureTest {
          @Test
          public void error() throws Exception {
              org.junit.Assert.fail();
          }
      }
  
      public void testRunFailure() throws Exception {
         JUnitCore runner = new JUnitCore();
         Result result = runner.run(FailureTest.class);
         assertEquals(1, result.getRunCount());
         assertEquals(1, result.getFailureCount());
         assertEquals(AssertionError.class, result.getFailures().get(0).getException().getClass());
     }
 
     static public class SetupFailureTest {
         @Before
         public void before() {
             throw new Error();
         }
 
         @Test
         public void test() {
             run = true;
         }
     }
 
     public void testSetupFailure() throws Exception {
         JUnitCore core = new JUnitCore();
         Result runner = core.run(SetupFailureTest.class);
         assertEquals(1, runner.getRunCount());
         assertEquals(1, runner.getFailureCount());
         assertEquals(Error.class, runner.getFailures().get(0).getException().getClass());
         assertFalse(run);
     }
 
     static public class TeardownFailureTest {
         @After
         public void after() {
             throw new Error();
         }
 
         @Test
         public void test() {
         }
     }
 
     public void testTeardownFailure() throws Exception {
         JUnitCore core = new JUnitCore();
         Result runner = core.run(TeardownFailureTest.class);
         assertEquals(1, runner.getRunCount());
         assertEquals(1, runner.getFailureCount());
         assertEquals(Error.class, runner.getFailures().get(0).getException().getClass());
     }
 
     static public class TestAndTeardownFailureTest {
         @After
         public void after() {
             throw new Error("hereAfter");
         }
 
         @Test
         public void test() throws Exception {
             throw new Exception("inTest");
         }
     }
 
     public void testTestAndTeardownFailure() throws Exception {
         JUnitCore core = new JUnitCore();
         Result runner = core.run(TestAndTeardownFailureTest.class);
         assertEquals(1, runner.getRunCount());
         assertEquals(2, runner.getFailureCount());
         assertThat(runner.getFailures().toString(), allOf(containsString("hereAfter"), containsString("inTest")));
     }
 
     static public class TeardownAfterFailureTest {
         @After
         public void after() {
             run = true;
         }
 
         @Test
         public void test() throws Exception {
             throw new Exception();
         }
     }
 
     public void testTeardownAfterFailure() throws Exception {
         JUnitCore runner = new JUnitCore();
         runner.run(TeardownAfterFailureTest.class);
         assertTrue(run);
     }
 
     static int count;
     static Collection<Object> tests;
 
     static public class TwoTests {
         @Test
         public void one() {
             count++;
             tests.add(this);
         }
 
         @Test
         public void two() {
             count++;
             tests.add(this);
         }
     }
 
     public void testTwoTests() throws Exception {
         count = 0;
         tests = new HashSet<Object>();
         JUnitCore runner = new JUnitCore();
         runner.run(TwoTests.class);
         assertEquals(2, count);
         assertEquals(2, tests.size());
     }
 
     static public class OldTest extends TestCase {
         public void test() {
             run = true;
         }
     }
 
     public void testOldTest() throws Exception {
         JUnitCore runner = new JUnitCore();
         runner.run(OldTest.class);
         assertTrue(run);
     }
 
     static public class OldSuiteTest extends TestCase {
         public void testOne() {
             run = true;
         }
     }
 
     public void testOldSuiteTest() throws Exception {
         TestSuite suite = new TestSuite(OldSuiteTest.class);
         JUnitCore runner = new JUnitCore();
         runner.run(suite);
         assertTrue(run);
     }
 
     static public class ExceptionTest {
         @Test(expected = Error.class)
         public void expectedException() {
             throw new Error();
         }
     }
 
     public void testException() throws Exception {
         JUnitCore core = new JUnitCore();
         Result result = core.run(ExceptionTest.class);
         assertEquals(0, result.getFailureCount());
     }
 
     static public class NoExceptionTest {
         @Test(expected = Error.class)
         public void expectedException() {
         }
     }
 
     public void testExceptionNotThrown() throws Exception {
         JUnitCore core = new JUnitCore();
         Result result = core.run(NoExceptionTest.class);
         assertEquals(1, result.getFailureCount());
         assertEquals("Expected exception: java.lang.Error", result.getFailures().get(0).getMessage());
     }
 
     static public class OneTimeSetup {
         @BeforeClass
         public static void once() {
             count++;
         }
 
         @Test
         public void one() {
         }
 
         @Test
         public void two() {
         }
     }
 
     public void testOneTimeSetup() throws Exception {
         count = 0;
         JUnitCore core = new JUnitCore();
         core.run(OneTimeSetup.class);
         assertEquals(1, count);
     }
 
     static public class OneTimeTeardown {
         @AfterClass
         public static void once() {
             count++;
         }
 
         @Test
         public void one() {
         }
 
         @Test
         public void two() {
         }
     }
 
     public void testOneTimeTeardown() throws Exception {
         count = 0;
         JUnitCore core = new JUnitCore();
         core.run(OneTimeTeardown.class);
         assertEquals(1, count);
     }
 
     static String log;
 
     public static class OrderTest {
         @BeforeClass
         public static void onceBefore() {
             log += "beforeClass ";
         }
 
         @Before
         public void before() {
             log += "before ";
         }
 
         @Test
         public void test() {
             log += "test ";
         }
 
         @After
         public void after() {
             log += "after ";
         }
 
         @AfterClass
         public static void onceAfter() {
             log += "afterClass ";
         }
     }
 
     public void testOrder() throws Exception {
         log = "";
         JUnitCore core = new JUnitCore();
         core.run(OrderTest.class);
         assertEquals("beforeClass before test after afterClass ", log);
     }
 
     static public class NonStaticOneTimeSetup {
         @BeforeClass
         public void once() {
         }
 
         @Test
         public void aTest() {
         }
     }
 
     public void testNonStaticOneTimeSetup() throws Exception {
         JUnitCore core = new JUnitCore();
         Result result = core.run(NonStaticOneTimeSetup.class);
         assertEquals(1, result.getFailureCount());
     }
 
     static public class ErrorInBeforeClass {
         @BeforeClass
         public static void before() throws Exception {
             throw new Exception();
         }
 
         @Test
         public void test() {
             run = true;
         }
     }
 
     public void testErrorInBeforeClass() throws Exception {
         run = false;
         JUnitCore core = new JUnitCore();
         Result result = core.run(ErrorInBeforeClass.class);
         assertFalse(run);
         assertEquals(1, result.getFailureCount());
         Description description = result.getFailures().get(0).getDescription();
         assertEquals(ErrorInBeforeClass.class.getName(), description.getDisplayName());
     }
 
     static public class ErrorInAfterClass {
         @Test
         public void test() {
             run = true;
         }
 
         @AfterClass
         public static void after() throws Exception {
             throw new Exception();
         }
     }
 
     public void testErrorInAfterClass() throws Exception {
         run = false;
         JUnitCore core = new JUnitCore();
         Result result = core.run(ErrorInAfterClass.class);
         assertTrue(run);
         assertEquals(1, result.getFailureCount());
     }
 
     static public class SuperInheritance {
         @BeforeClass
         static public void beforeClassSuper() {
             log += "Before class super ";
         }
 
         @AfterClass
         static public void afterClassSuper() {
             log += "After class super ";
         }
 
         @Before
         public void beforeSuper() {
             log += "Before super ";
         }
 
         @After
         public void afterSuper() {
             log += "After super ";
         }
     }
 
     static public class SubInheritance extends SuperInheritance {
         @BeforeClass
         static public void beforeClassSub() {
             log += "Before class sub ";
         }
 
         @AfterClass
         static public void afterClassSub() {
             log += "After class sub ";
         }
 
         @Before
         public void beforeSub() {
             log += "Before sub ";
         }
 
         @After
         public void afterSub() {
             log += "After sub ";
         }
 
         @Test
         public void test() {
             log += "Test ";
         }
     }
 
     public void testOrderingOfInheritance() throws Exception {
         log = "";
         JUnitCore core = new JUnitCore();
         core.run(SubInheritance.class);
         assertEquals("Before class super Before class sub Before super Before sub Test After sub After super After class sub After class super ", log);
     }
 
     static public class SuperShadowing {
         @Before
         public void before() {
             log += "Before super ";
         }
 
         @After
         public void after() {
             log += "After super ";
         }
     }
 
     static public class SubShadowing extends SuperShadowing {
         @Override
         @Before
         public void before() {
             log += "Before sub ";
         }
 
         @Override
         @After
         public void after() {
             log += "After sub ";
         }
 
         @Test
         public void test() {
             log += "Test ";
         }
     }
 
     public void testShadowing() throws Exception {
         log = "";
         JUnitCore core = new JUnitCore();
         core.run(SubShadowing.class);
         assertEquals("Before sub Test After sub ", log);
     }
 
     static public class SuperTest {
         @Test
         public void one() {
             log += "Super";
         }
 
         @Test
         public void two() {
             log += "Two";
         }
     }
 
     static public class SubTest extends SuperTest {
         @Override
         @Test
         public void one() {
             log += "Sub";
         }
     }
 
     public void testTestInheritance() throws Exception {
         log = "";
         JUnitCore core = new JUnitCore();
         core.run(SubTest.class);
         // The order in which the test methods are called is unspecified
         assertTrue(log.contains("Sub"));
         assertTrue(log.contains("Two"));
         assertFalse(log.contains("Super"));
     }
 
     static public class RunAllAfters {
         @Before
         public void good() {
         }
 
         @Before
         public void bad() {
             throw new Error();
         }
 
         @Test
         public void empty() {
         }
 
         @After
         public void one() {
             log += "one";
         }
 
         @After
         public void two() {
             log += "two";
         }
     }
 
     public void testRunAllAfters() {
         log = "";
         JUnitCore core = new JUnitCore();
         core.run(RunAllAfters.class);
         assertTrue(log.contains("one"));
         assertTrue(log.contains("two"));
     }
 
     static public class RunAllAftersRegardless {
         @Test
         public void empty() {
         }
 
         @After
         public void one() {
             log += "one";
             throw new Error();
         }
 
         @After
         public void two() {
             log += "two";
             throw new Error();
         }
     }
 
     public void testRunAllAftersRegardless() {
         log = "";
         JUnitCore core = new JUnitCore();
         Result result = core.run(RunAllAftersRegardless.class);
         assertTrue(log.contains("one"));
         assertTrue(log.contains("two"));
         assertEquals(2, result.getFailureCount());
     }
 
     static public class RunAllAfterClasses {
         @Before
         public void good() {
         }
 
         @BeforeClass
         public static void bad() {
             throw new Error();
         }
 
         @Test
         public void empty() {
         }
 
         @AfterClass
         public static void one() {
             log += "one";
         }
 
         @AfterClass
         public static void two() {
             log += "two";
         }
     }
 
     public void testRunAllAfterClasses() {
         log = "";
         JUnitCore core = new JUnitCore();
         core.run(RunAllAfterClasses.class);
         assertTrue(log.contains("one"));
         assertTrue(log.contains("two"));
     }
 
     static public class RunAllAfterClassesRegardless {
         @Test
         public void empty() {
         }
 
         @AfterClass
         static public void one() {
             log += "one";
             throw new Error();
         }
 
         @AfterClass
         static public void two() {
             log += "two";
             throw new Error();
         }
     }
 
     public void testRunAllAfterClassesRegardless() {
         log = "";
         JUnitCore core = new JUnitCore();
         Result result = core.run(RunAllAfterClassesRegardless.class);
         assertTrue(log.contains("one"));
         assertTrue(log.contains("two"));
         assertEquals(2, result.getFailureCount());
     }
 }