I'm doing Test-Driven-Development with Java course, after having not done one for a long time, and I was browsing through my samples and online to see if anything interesting in JUnit land has happened since last time. And there sure is!

JUnit 4 is out and allows using Java Annotations (Java's version of .NET Attributes if you will) to write tests. No need for inheritance anymore, or to begin test names with 'test". simply use annotations:

Here is an example takes from this blog, which has a more elaborate list of changes with examples:

Test Annotations:

   

    
    @Test 
    public
     
    void
     emptyTest() { stack 
    =
     
    new
     Stack
    <
    String
    >
    (); assertTrue(stack.isEmpty()); }
   

(I'm using the cool Code formatter live writer plugin )

Also, you get matching annotations for setup and teardown:

   

    
    public
     
    class
     OutputTest { 
    private
     File output; @Before 
    public
     
    void
     createOutputFile() { output 
    =
     
    new
     File(...); } @After 
    public
     
    void
     deleteOutputFile() { output.delete(); } @Test 
    public
     
    void
     testSomethingWithFile() { ... } }
   

For some weird reason, it's possible to put this annotation on multiple methods in the same test fixture, and they will all run in an unknown order. Not sure why that is useful, or at all contributes to readability..

You also get to test for expected exceptions more easily:

   

    
    @Test(expected
    =
    IndexOutOfBoundsException.
    class
    ) 
    public
     
    void
     testIndexOutOfBoundsException() { ArrayList emptyList 
    =
     
    new
     ArrayList(); Object o 
    =
     emptyList.get(
    0
    ); }
   

Parameterized Tests

One feature I was pretty surprised to see, but rather glad that I saw it, the fact that, a bit like in MbUnit, JUnit 4 has support for tests that can take parameters, and thus being able to run the test multiple times with different inputs.

Differently than JUnit though, you need to create a class for each Parameterized test you'd like to create, and put annotations on the class, and on the source of the parameters (data source, if you will). this allows a more data-driven-testing kind of way, which is a bit like what you can find in VSTS Unit Testing support.

   

    
    @RunWith
    (value 
    =
     Parameterized.class) 
    public
     class StackTest { Stack
    <
    Integer
    >
     stack; private 
    int
     
    number
    ; 
    public
     StackTest(
    int
     
    number
    ) { this.
    number
     
    =
     
    number
    ; } 
    @Parameters
     
    public
     static Collection data() { Object
    [][]
     data 
    =
     new Object
    [][]
     { { 
    1
     }, { 
    2
     }, { 
    3
     }, { 
    4
     } }; 
    return
     Arrays.asList(data); } ... }
   

Test Suites

Creating Test Suites with JUnit 4 is rather a weird task. You create an empty class with the sole takes of carrying annotations that point to the class list to run:

   

    
    @RunWith
    (Suite.class) 
    @Suite
    .SuiteClasses({StackTest.class}) 
    public
     class AllTests { }