从Java运行TestCase并在Eclipse JUnit视图上显示结果

Question

I defined some classes with, each one, several public methods with @Test annotation. All methods follow the same behavioral pattern (retrieve ressources from IDs, test if empty, log, call the real test for each line on the resource). So, I've externalized this behavior in an abstract class I instanciate on each method, like this:

@Test
public void someTest(){
  new BasicTestPattern("X","Y","Z"){ // some parameters to retrieve resources
     @Override
     protected void testLine(){ 
        someCheck1();
        someCheck2();
     }
  }.run();
}

This solution eliminate 10-30 lines per test method. Now, I want to go further with a custom annotation, like that:

@TestPattern(param1="X",param2="Y",param3="Z")
public void someTest(){
  someCheck1();
  someCheck2();
}

Finally I created a little framework to retrieve all the methods with this new annotation in order to instanciate BasicTestPattern and execute it. It is executed well in a TestCase subclass, like that:

TestCase junit_test = new TestCase(){
  @Override
  public void runTest() {
    pattern.run();
  }
};

junit_test.run();

However, no Test is displayed/listed in the JUnit view from Eclipse. I see only the number of tests succeeded. How can I do that ? Thank you.

Answer 1

You probably will need to make your own custom Runner to find all the methods annotated with your @TestPattern method. (and probably also with @Test ?)

Then your test class will look like this:

@RunWith(YourRunner.class)
public class YourTest{

   @TestPattern(param1="X",param2="Y",param3="Z")
   public void someTest(){
        ...
   }

   @Test
   public void anotherNormalTest(){
        ...
   }


}

This Blog explains how to write custom Runners. But you can probably get away with extending BlockJUnit4ClassRunner to add the your special test methods to the list of tests to run.

I think you would only have to override the computeTestMethods() method which is how BlockJUnit4ClassRunner finds all the test methods to run (the methods annotated with @Test) you can override it to find the methods you annotated with your own annotation.

  public class your TestRunner extends BlockJUnit4ClassRunner{

  protected List<FrameworkMethod> computeTestMethods() {
        //this is all the @Test annotated methods
        List<FrameworkMethod> testAnnotatedMethods = super.computeTestMethods();
        //these are all the methods with your @TestPattern annotation
        List<FrameworkMethod> yourAnnotatedMethods = getTestClass().getAnnotatedMethods(TestPattern.class);

        //do whatever you need to do to generate the test 
        //methods with the correct parameters based on 
        //the annotation ?  
        //Might need to make fake or 
        //synthetic FrameworkMethod instances?

       ...

       //combine everyting into a single List
       List<FrameworkMethod> allTestMethods =...
       //finally return all the FrameworkMethods as a single list
       return allTestMethods;
 }

}

You might have to make your own FrameworkMethod implementation wrapper to get the info from the annotation and do whatever set up is required before invoking the method.

This will make it seamlessly integrate with normal JUnit classes and work with the JUnit IDE view

Good Luck