package org.junit.rules;
   
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertTrue;
   
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
   
  import org.junit.Assert;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.runner.Description;
  import org.junit.runner.JUnitCore;
  import org.junit.runner.Result;
  import org.junit.runners.model.Statement;
  
  public class DisableOnDebugTest {
      private static final List<String> WITHOUT_DEBUG_ARGUMENTS = Collections
              .emptyList();
  
      private static final List<String> PRE_JAVA5_DEBUG_ARGUMENTS = Arrays
              .asList("-Xdebug",
                      "-Xrunjdwp:transport=dt_socket,server=y,address=8000");
  
      private static final List<String> PRE_JAVA5_DEBUG_ARGUMENTS_IN_REVERSE_ORDER = Arrays
              .asList("-Xrunjdwp:transport=dt_socket,server=y,address=8000",
                      "-Xdebug");
  
      private static final List<String> POST_JAVA5_DEBUG_ARGUMENTS = Arrays
              .asList("-agentlib:jdwp=transport=dt_socket,server=y,address=8000");
  
      /**
       * Nasty rule that always fails
       */
      private static class FailOnExecution implements TestRule {
  
          public Statement apply(Statement base,
                  Description description) {
              return new Statement() {
  
                  @Override
                  public void evaluate() throws Throwable {
                      throw new AssertionError();
                  }
              };
          }
  
      }
  
      public static abstract class AbstractDisableOnDebugTest {
  
          @Rule
          public TestRule failOnExecution;
  
          public AbstractDisableOnDebugTest(List<String> arguments) {
              this.failOnExecution = new DisableOnDebug(new FailOnExecution(),
                      arguments);
          }
  
          @Test
          public void test() {
          }
      }
  
      public static class PreJava5DebugArgumentsTest extends
              AbstractDisableOnDebugTest {
  
          public PreJava5DebugArgumentsTest() {
              super(PRE_JAVA5_DEBUG_ARGUMENTS);
          }
  
      }
  
      public static class PreJava5DebugArgumentsReversedTest extends
              AbstractDisableOnDebugTest {
  
          public PreJava5DebugArgumentsReversedTest() {
              super(PRE_JAVA5_DEBUG_ARGUMENTS_IN_REVERSE_ORDER);
          }
  
      }
  
      public static class PostJava5DebugArgumentsTest extends
              AbstractDisableOnDebugTest {
  
          public PostJava5DebugArgumentsTest() {
              super(POST_JAVA5_DEBUG_ARGUMENTS);
          }
  
      }
  
      public static class WithoutDebugArgumentsTest extends
              AbstractDisableOnDebugTest {
  
          public WithoutDebugArgumentsTest() {
              super(WITHOUT_DEBUG_ARGUMENTS);
          }
  
     }
 
     @Test
     public void givenPreJava5DebugArgumentsIsDebuggingShouldReturnTrue() {
         DisableOnDebug subject = new DisableOnDebug(
                 new FailOnExecution(), PRE_JAVA5_DEBUG_ARGUMENTS);
         assertTrue("Should be debugging", subject.isDebugging());
     }
 
     @Test
     public void givenPreJava5DebugArgumentsInReverseIsDebuggingShouldReturnTrue() {
         DisableOnDebug subject = new DisableOnDebug(
                 new FailOnExecution(),
                 PRE_JAVA5_DEBUG_ARGUMENTS_IN_REVERSE_ORDER);
         assertTrue("Should be debugging", subject.isDebugging());
     }
 
     @Test
     public void givenPostJava5DebugArgumentsIsDebuggingShouldReturnTrue() {
         DisableOnDebug subject = new DisableOnDebug(
                 new FailOnExecution(), POST_JAVA5_DEBUG_ARGUMENTS);
         assertTrue("Should be debugging", subject.isDebugging());
     }
 
     @Test
     public void givenArgumentsWithoutDebugFlagsIsDebuggingShouldReturnFalse() {
         DisableOnDebug subject = new DisableOnDebug(
                 new FailOnExecution(), WITHOUT_DEBUG_ARGUMENTS);
         Assert.assertFalse("Should not be debugging", subject.isDebugging());
     }
 
     @Test
     public void whenRunWithPreJava5DebugArgumentsTestShouldFail() {
         JUnitCore core = new JUnitCore();
         Result result = core.run(PreJava5DebugArgumentsTest.class);
         assertEquals("Should run the test", 1, result.getRunCount());
         assertEquals("Test should not have failed", 0, result.getFailureCount());
     }
 
     @Test
     public void whenRunWithPreJava5DebugArgumentsInReverseOrderTestShouldFail() {
         JUnitCore core = new JUnitCore();
         Result result = core
                 .run(PreJava5DebugArgumentsReversedTest.class);
         assertEquals("Should run the test", 1, result.getRunCount());
         assertEquals("Test should not have failed", 0, result.getFailureCount());
     }
 
     @Test
     public void whenRunWithPostJava5DebugArgumentsTestShouldFail() {
         JUnitCore core = new JUnitCore();
         Result result = core.run(PostJava5DebugArgumentsTest.class);
         assertEquals("Should run the test", 1, result.getRunCount());
         assertEquals("Test should not have failed", 0, result.getFailureCount());
     }
 
     @Test
     public void whenRunWithoutDebugFlagsTestShouldPass() {
         JUnitCore core = new JUnitCore();
         Result result = core.run(WithoutDebugArgumentsTest.class);
         assertEquals("Should run the test", 1, result.getRunCount());
         assertEquals("Test should have failed", 1, result.getFailureCount());
     }
 
 }