Java Unit Testing - constant fields versus setUp()

Question

I am writing a test class for an implementation of an interface, and want to test my implementation against another implementation (i.e. to ensure consistency). The test methods will then test each of the interface methods to check this.

To do this I could:

a) create a private static constant fields of the original implementation and my new implementation:

public class MyImplTest extends TestCase {

  private static OldImpl _original;
  private static MyImpl _myImpl;
  static {
    // instantiate _original and _myImpl
  }

  // My tests
}

b) create private fields of the two implementations, and instantiate them using setUp():

public class MyImplTest extends TestCase {
  private OldImpl _original;
  private MyImpl _myImpl;

  public void setUp(){
    // instantiate _original and _myImpl
  }

  // My tests
}

Is either of these preferred / considered good style? My instinct suggests (b), but I want to create quite large objects, and setUp() gets run for each testSomething() method in the TestCase, so both _original and _myImpl would be created multiple times.

FWIW, I'm using JUnit 3.

Answer 1

Using the setup method will cause the initialization code to run before each test. Static initializers will run once (and only once) when the class is first loaded, which means they will execute only once per test run.

It is often a better idea to initialize everything fresh for each test, just to remove the ability of the state of any objects from one test affecting other tests.

The only time I have found using static initialization to be useful was when I was writing integration (not unit) tests and my class under test was expensive to construct. I was certain that the object was stateless though so that tests could not interfere with each other. If you aren't certain, it is better to use the setup() method to be safe.