Best Practice Initialize JUnit class fields in setUp or at declaration

Question

Should I initialize class fields at declaration like this   public class SomeTest extends TestCase       private final List list   new ArrayList         public void testPopulateList                    Add stuff to the list            Assert the list contains what I expect           Or in setUp   like this   public class SomeTest extends TestCase       private List list        Override     protected void setUp   throws Exception               super setUp            this list   new ArrayList               public void testPopulateList                    Add stuff to the list            Assert the list contains what I expect           I tend to use the first form because it s more concise  and allows me to use final fields   If I don t need to use the setUp   method for set-up  should I still use it  and why   Clarification  JUnit will instantiate the test class once per test method   That means list will be created once per test  regardless of where I declare it   It also means there are no temporal dependencies between the tests   So it seems like there are no advantages to using setUp     However the JUnit FAQ has many examples that initialize an empty collection in setUp    so I figure there must be a reason

User · Answer

I prefer readability first which most often does not use the setup method. I make an exception when a basic setup operation takes a long time and is repeated within each test.
At that point I move that functionality into a setup method using the @BeforeClass annotation (optimize later).

Example of optimization using the @BeforeClass setup method: I use dbunit for some database functional tests. The setup method is responsible for putting the database in a known state (very slow... 30 seconds - 2 minutes depending on amount of data). I load this data in the setup method annotated with @BeforeClass and then run 10-20 tests against the same set of data as opposed to re-loading/initializing the database inside each test.

Using Junit 3.8 (extending TestCase as shown in your example) requires writing a little more code than just adding an annotation, but the "run once before class setup" is still possible.

User · Answer

In addition to Alex B s answer   It is even required to use the setUp method to instantiate resources in a certain state  Doing this in the constructor is not only a matter of timings  but because of the way JUnit runs the tests  each test state would be erased after running one   JUnit first creates instances of the testClass for each test method and starts running the tests after each instance is created  Before running the test method  its setup method is ran  in which some state can be prepared   If the database state would be created in the constructor  all instances would instantiate the db state right after each other  before running each tests  As of the second test  tests would run with a dirty state   JUnits lifecycle    Create a different testclass instance for each test method Repeat for each testclass instance  call setup   call the testmethod   With some loggings in a test with two test methods you get   number is the hashcode    Creating new instance  5718203 Creating new instance  5947506 Setup  5718203 TestOne  5718203 Setup  5947506 TestTwo  5947506

User · Answer

I started digging myself and I found one potential advantage of using setUp     If any exceptions are thrown during the execution of setUp    JUnit will print a very helpful stack trace   On the other hand  if an exception is thrown during object construction  the error message simply says JUnit was unable to instantiate the test case and you don t see the line number where the failure occurred  probably because JUnit uses reflection to instantiate the test classes   None of this applies to the example of creating an empty collection  since that will never throw  but it is an advantage of the setUp   method

User · Answer

In JUnit 3  your field initializers will be run once per test method before any tests are run   As long as your field values are small in memory  take little set up time  and do not affect global state  using field initializers is technically fine   However  if those do not hold  you may end up consuming a lot of memory or time setting up your fields before the first test is run  and possibly even running out of memory   For this reason  many developers always set field values in the setUp   method  where it s always safe  even when it s not strictly necessary   Note that in JUnit 4  test object initialization happens right before test running  and so using field initializers is safer  and recommended style

User · Answer

I started digging myself and I found one potential advantage of using setUp     If any exceptions are thrown during the execution of setUp    JUnit will print a very helpful stack trace   On the other hand  if an exception is thrown during object construction  the error message simply says JUnit was unable to instantiate the test case and you don t see the line number where the failure occurred  probably because JUnit uses reflection to instantiate the test classes   None of this applies to the example of creating an empty collection  since that will never throw  but it is an advantage of the setUp   method

User · Answer

I prefer readability first which most often does not use the setup method. I make an exception when a basic setup operation takes a long time and is repeated within each test.
At that point I move that functionality into a setup method using the @BeforeClass annotation (optimize later).

Example of optimization using the @BeforeClass setup method: I use dbunit for some database functional tests. The setup method is responsible for putting the database in a known state (very slow... 30 seconds - 2 minutes depending on amount of data). I load this data in the setup method annotated with @BeforeClass and then run 10-20 tests against the same set of data as opposed to re-loading/initializing the database inside each test.

Using Junit 3.8 (extending TestCase as shown in your example) requires writing a little more code than just adding an annotation, but the "run once before class setup" is still possible.

User · Answer

I started digging myself and I found one potential advantage of using setUp     If any exceptions are thrown during the execution of setUp    JUnit will print a very helpful stack trace   On the other hand  if an exception is thrown during object construction  the error message simply says JUnit was unable to instantiate the test case and you don t see the line number where the failure occurred  probably because JUnit uses reflection to instantiate the test classes   None of this applies to the example of creating an empty collection  since that will never throw  but it is an advantage of the setUp   method

User · Answer

In JUnit 3  your field initializers will be run once per test method before any tests are run   As long as your field values are small in memory  take little set up time  and do not affect global state  using field initializers is technically fine   However  if those do not hold  you may end up consuming a lot of memory or time setting up your fields before the first test is run  and possibly even running out of memory   For this reason  many developers always set field values in the setUp   method  where it s always safe  even when it s not strictly necessary   Note that in JUnit 4  test object initialization happens right before test running  and so using field initializers is safer  and recommended style

User · Answer

If you re wondering specifically about the examples in the JUnit FAQ  such as the basic test template  I think the best practice being shown off there is that the class under test should be instantiated in your setUp method  or in a test method    When the JUnit examples create an ArrayList in the setUp method  they all go on to test the behavior of that ArrayList  with cases like testIndexOutOfBoundException  testEmptyCollection  and the like  The perspective there is of someone writing a class and making sure it works right   You should probably do the same when testing your own classes  create your object in setUp or in a test method  so that you ll be able to get reasonable output if you break it later   On the other hand  if you use a Java collection class  or other library class  for that matter  in your test code  it s probably not because you want to test it--it s just part of the test fixture  In this case  you can safely assume it works as intended  so initializing it in the declaration won t be a problem   For what it s worth  I work on a reasonably large  several-year-old  TDD-developed code base  We habitually initialize things in their declarations in test code  and in the year and a half that I ve been on this project  it has never caused a problem  So there s at least some anecdotal evidence that it s a reasonable thing to do

User · Answer

The constant values  uses in fixtures or assertions  should be initialized in their declarations and final  as never change   the object under test should be initialized in the setup method because we may set things on   Of course we may not set something now but we could set it later  Instantiating in the init method would ease the changes     dependencies of the object under test if these are mocked  should not even be instantiated by yourself   today the mock frameworks can instantiate it by reflection        A test without dependency to mock could look like    public class SomeTest        Some some    instance under test     static final String GENERIC ID    123       static final String PREFIX URL WS    http   foo com ws         Before     public void beforeEach            some   new Some new Foo    new Bar                  Test     public void populateList                          A test with dependencies to isolate could look like     RunWith org mockito runners MockitoJUnitRunner class  public class SomeTest        Some some    instance under test     static final String GENERIC ID    123       static final String PREFIX URL WS    http   foo com ws         Mock     Foo fooMock        Mock     Bar barMock        Before     public void beforeEach            some   new Some fooMock  barMock               Test     public void populateList

User · Answer

If you re wondering specifically about the examples in the JUnit FAQ  such as the basic test template  I think the best practice being shown off there is that the class under test should be instantiated in your setUp method  or in a test method    When the JUnit examples create an ArrayList in the setUp method  they all go on to test the behavior of that ArrayList  with cases like testIndexOutOfBoundException  testEmptyCollection  and the like  The perspective there is of someone writing a class and making sure it works right   You should probably do the same when testing your own classes  create your object in setUp or in a test method  so that you ll be able to get reasonable output if you break it later   On the other hand  if you use a Java collection class  or other library class  for that matter  in your test code  it s probably not because you want to test it--it s just part of the test fixture  In this case  you can safely assume it works as intended  so initializing it in the declaration won t be a problem   For what it s worth  I work on a reasonably large  several-year-old  TDD-developed code base  We habitually initialize things in their declarations in test code  and in the year and a half that I ve been on this project  it has never caused a problem  So there s at least some anecdotal evidence that it s a reasonable thing to do

User · Answer

Since each test is executed independently  with a fresh instance of the object  there s not much point to the Test object having any internal state except that shared between setUp   and an individual test and tearDown     This is one reason  in addition to the reasons others gave  that it s good to use the setUp   method   Note   It s a bad idea for a JUnit test object to maintain static state   If you make use of static variable in your tests for anything other than tracking or diagnostic purposes  you are invalidating part of the purpose of JUnit  which is that the tests can  an may  be run in any order  each test running with a fresh  clean state   The advantages to using setUp   is that you don t have to cut-and-paste initialization code in every test method and that you don t have test setup code in the constructor   In your case  there is little difference   Just creating an empty list can be done safely as you show it or in the constructor as it s a trivial initialization   However  as you and others have pointed out  anything that can possibly throw an Exception should be done in setUp   so you get the diagnostic stack dump if it fails   In your case  where you are just creating an empty list  I would do the same way you are suggesting   Assign the new list at the point of declaration   Especially because this way you have the option of marking it final if this makes sense for your test class

User · Answer

In JUnit 4    For the Class Under Test  initialize in a  Before method  to catch failures  For other classes  initialize in the declaration         for brevity  and to mark fields final  exactly as stated in the question     unless it is complex initialization that could fail  in which case use  Before  to catch failures   For global state  esp  slow initialization  like a database   use  BeforeClass  but be careful of dependencies between tests  Initialization of an object used in a single test should of course be done in the test method itself    Initializing in a  Before method or test method allows you to get better error reporting on failures  This is especially useful for instantiating the Class Under Test  which you might break   but is also useful for calling external systems  like filesystem access   file not found   or connecting to a database   connection refused     It is acceptable to have a simple standard and always use  Before  clear errors but verbose  or always initialize in declaration  concise but gives confusing errors   since complex coding rules are hard to follow  and this isn t a big deal   Initializing in setUp is a relic of JUnit 3  where all test instances were initialized eagerly  which causes problems  speed  memory  resource exhaustion  if you do expensive initialization  Thus best practice was to do expensive initialization in setUp  which was only run when the test was executed  This no longer applies  so it is much less necessary to use setUp   This summarizes several other replies that bury the lede  notably by Craig P  Motlin  question itself and self-answer   Moss Collum  class under test   and dsaff

User · Answer

I started digging myself and I found one potential advantage of using setUp     If any exceptions are thrown during the execution of setUp    JUnit will print a very helpful stack trace   On the other hand  if an exception is thrown during object construction  the error message simply says JUnit was unable to instantiate the test case and you don t see the line number where the failure occurred  probably because JUnit uses reflection to instantiate the test classes   None of this applies to the example of creating an empty collection  since that will never throw  but it is an advantage of the setUp   method

User · Answer

In your case  creating a list  there is no difference in practice  But generally it is better to use setUp    because that will help Junit to report Exceptions correctly  If an exception occurs in constructor initializer of a Test  that is a test failure  However  if an exception occurs during setup  it is natural to think of it as some issue in setting up the test  and junit reports it appropriately

User · Answer

I prefer readability first which most often does not use the setup method. I make an exception when a basic setup operation takes a long time and is repeated within each test.
At that point I move that functionality into a setup method using the @BeforeClass annotation (optimize later).

Example of optimization using the @BeforeClass setup method: I use dbunit for some database functional tests. The setup method is responsible for putting the database in a known state (very slow... 30 seconds - 2 minutes depending on amount of data). I load this data in the setup method annotated with @BeforeClass and then run 10-20 tests against the same set of data as opposed to re-loading/initializing the database inside each test.

Using Junit 3.8 (extending TestCase as shown in your example) requires writing a little more code than just adding an annotation, but the "run once before class setup" is still possible.

User · Answer

In addition to Alex B s answer   It is even required to use the setUp method to instantiate resources in a certain state  Doing this in the constructor is not only a matter of timings  but because of the way JUnit runs the tests  each test state would be erased after running one   JUnit first creates instances of the testClass for each test method and starts running the tests after each instance is created  Before running the test method  its setup method is ran  in which some state can be prepared   If the database state would be created in the constructor  all instances would instantiate the db state right after each other  before running each tests  As of the second test  tests would run with a dirty state   JUnits lifecycle    Create a different testclass instance for each test method Repeat for each testclass instance  call setup   call the testmethod   With some loggings in a test with two test methods you get   number is the hashcode    Creating new instance  5718203 Creating new instance  5947506 Setup  5718203 TestOne  5718203 Setup  5947506 TestTwo  5947506

User · Answer

The constant values  uses in fixtures or assertions  should be initialized in their declarations and final  as never change   the object under test should be initialized in the setup method because we may set things on   Of course we may not set something now but we could set it later  Instantiating in the init method would ease the changes     dependencies of the object under test if these are mocked  should not even be instantiated by yourself   today the mock frameworks can instantiate it by reflection        A test without dependency to mock could look like    public class SomeTest        Some some    instance under test     static final String GENERIC ID    123       static final String PREFIX URL WS    http   foo com ws         Before     public void beforeEach            some   new Some new Foo    new Bar                  Test     public void populateList                          A test with dependencies to isolate could look like     RunWith org mockito runners MockitoJUnitRunner class  public class SomeTest        Some some    instance under test     static final String GENERIC ID    123       static final String PREFIX URL WS    http   foo com ws         Mock     Foo fooMock        Mock     Bar barMock        Before     public void beforeEach            some   new Some fooMock  barMock               Test     public void populateList

User · Answer

In JUnit 4    For the Class Under Test  initialize in a  Before method  to catch failures  For other classes  initialize in the declaration         for brevity  and to mark fields final  exactly as stated in the question     unless it is complex initialization that could fail  in which case use  Before  to catch failures   For global state  esp  slow initialization  like a database   use  BeforeClass  but be careful of dependencies between tests  Initialization of an object used in a single test should of course be done in the test method itself    Initializing in a  Before method or test method allows you to get better error reporting on failures  This is especially useful for instantiating the Class Under Test  which you might break   but is also useful for calling external systems  like filesystem access   file not found   or connecting to a database   connection refused     It is acceptable to have a simple standard and always use  Before  clear errors but verbose  or always initialize in declaration  concise but gives confusing errors   since complex coding rules are hard to follow  and this isn t a big deal   Initializing in setUp is a relic of JUnit 3  where all test instances were initialized eagerly  which causes problems  speed  memory  resource exhaustion  if you do expensive initialization  Thus best practice was to do expensive initialization in setUp  which was only run when the test was executed  This no longer applies  so it is much less necessary to use setUp   This summarizes several other replies that bury the lede  notably by Craig P  Motlin  question itself and self-answer   Moss Collum  class under test   and dsaff

User · Answer

I prefer readability first which most often does not use the setup method. I make an exception when a basic setup operation takes a long time and is repeated within each test.
At that point I move that functionality into a setup method using the @BeforeClass annotation (optimize later).

Example of optimization using the @BeforeClass setup method: I use dbunit for some database functional tests. The setup method is responsible for putting the database in a known state (very slow... 30 seconds - 2 minutes depending on amount of data). I load this data in the setup method annotated with @BeforeClass and then run 10-20 tests against the same set of data as opposed to re-loading/initializing the database inside each test.

Using Junit 3.8 (extending TestCase as shown in your example) requires writing a little more code than just adding an annotation, but the "run once before class setup" is still possible.

User · Answer

In addition to Alex B s answer   It is even required to use the setUp method to instantiate resources in a certain state  Doing this in the constructor is not only a matter of timings  but because of the way JUnit runs the tests  each test state would be erased after running one   JUnit first creates instances of the testClass for each test method and starts running the tests after each instance is created  Before running the test method  its setup method is ran  in which some state can be prepared   If the database state would be created in the constructor  all instances would instantiate the db state right after each other  before running each tests  As of the second test  tests would run with a dirty state   JUnits lifecycle    Create a different testclass instance for each test method Repeat for each testclass instance  call setup   call the testmethod   With some loggings in a test with two test methods you get   number is the hashcode    Creating new instance  5718203 Creating new instance  5947506 Setup  5718203 TestOne  5718203 Setup  5947506 TestTwo  5947506

User · Answer

In your case  creating a list  there is no difference in practice  But generally it is better to use setUp    because that will help Junit to report Exceptions correctly  If an exception occurs in constructor initializer of a Test  that is a test failure  However  if an exception occurs during setup  it is natural to think of it as some issue in setting up the test  and junit reports it appropriately

User · Answer

Since each test is executed independently  with a fresh instance of the object  there s not much point to the Test object having any internal state except that shared between setUp   and an individual test and tearDown     This is one reason  in addition to the reasons others gave  that it s good to use the setUp   method   Note   It s a bad idea for a JUnit test object to maintain static state   If you make use of static variable in your tests for anything other than tracking or diagnostic purposes  you are invalidating part of the purpose of JUnit  which is that the tests can  an may  be run in any order  each test running with a fresh  clean state   The advantages to using setUp   is that you don t have to cut-and-paste initialization code in every test method and that you don t have test setup code in the constructor   In your case  there is little difference   Just creating an empty list can be done safely as you show it or in the constructor as it s a trivial initialization   However  as you and others have pointed out  anything that can possibly throw an Exception should be done in setUp   so you get the diagnostic stack dump if it fails   In your case  where you are just creating an empty list  I would do the same way you are suggesting   Assign the new list at the point of declaration   Especially because this way you have the option of marking it final if this makes sense for your test class

User · Answer

In addition to Alex B s answer   It is even required to use the setUp method to instantiate resources in a certain state  Doing this in the constructor is not only a matter of timings  but because of the way JUnit runs the tests  each test state would be erased after running one   JUnit first creates instances of the testClass for each test method and starts running the tests after each instance is created  Before running the test method  its setup method is ran  in which some state can be prepared   If the database state would be created in the constructor  all instances would instantiate the db state right after each other  before running each tests  As of the second test  tests would run with a dirty state   JUnits lifecycle    Create a different testclass instance for each test method Repeat for each testclass instance  call setup   call the testmethod   With some loggings in a test with two test methods you get   number is the hashcode    Creating new instance  5718203 Creating new instance  5947506 Setup  5718203 TestOne  5718203 Setup  5947506 TestTwo  5947506

[java] Best Practice: Initialize JUnit class fields in setUp() or at declaration?

Examples related to java

Examples related to junit