Should I nullify static variables in AfterClass (Java JUnit 4)?

Question

I created few static variables in @BeforeClass. Should I set them to null in @AfterClass? These are non IO related objects.

Example:

public class ClassTest{
   private static String staticText;   
   @BeforeClass
   public static void setUp(){
      staticText="long text";
   }
//test methods

//Is this necessary
@AfterClass
public static void tearDown(){
   staticText=null;
   }    
}

Why would this variable be static in the first place? Just make it non-static; then you wouldn't even have to worry about nulling it out. — Louis Wasserman, Dec 06 '12 at 23:11
The code I gave is just for the sake of example. Yes I read elsewhere that instance variables are safe to not null. It's the static variables I could not find information about. Does garbage collector destroy them immediately after the test class has finished running, or do those static objects hang in there untill JVM exists? Thanks — user1883896, Dec 06 '12 at 23:28
For non-static: http://stackoverflow.com/questions/3655944/is-it-really-necessary-to-nullify-objects-in-junit-teardown-methods — Ciro Santilli OurBigBook.com, Feb 19 '15 at 16:31

Mansoor Siddiqui · Answer 1 · 2018-02-07T03:45:59.770

9

Short Answer:

For static members: For both JUnit3 and JUnit4, static members are never eligible for garbage collection unless you explicitly nullify their references (e.g. in an @AfterClass method).

For non-static members: If you're using JUnit3, then it's good practice to nullify non-static member variables in your @After method. If you're using JUnit4 with the default test runner, then this practice is unnecessary.

Long Answer:

JUnit creates a separate instance of your test class for each test method that exists in that class. JUnit3 keeps the references to all of these instances around until the test suite has completed execution, so it is good practice to clean up these references in your tearDown() method. (Of course, since only one instance of a static variable exists across all instances of the class it belongs to, this is more important for non-static variables.)

JUnit4 still has the behavior of creating a separate instance of your test class for each test method, but as long as you're using the default test runner, then it only keeps a reference to the instance of your test class which the currently executing test belongs to. As a result, non-static member variables will be cleaned up even if you don't explicitly nullify them in your tearDown() method.

Beware, however, that if you use a custom JUnit4 test runner (via the @RunWith annotation), then there's no guarantee about how long it will keep around references to test class instances.

edited Feb 07 '18 at 03:45

answered Dec 06 '12 at 23:12

Mansoor Siddiqui

20,853
10
48
67

This is what I thought too, but I wanted to be sure that static objects don't remain in the memory until JVM exists. We have a fairly large test suite and it's important that memory is not clogged up. Can someone tell me if garbage collector takes care of these static variables on each test exit? Thanks – user1883896 Dec 06 '12 at 23:33
That's a good question -- which is why I researched how JUnit works a bit more and elaborated on my answer above. Hope it helps! – Mansoor Siddiqui Dec 13 '12 at 00:48
Just to add, this post provides even more detail about JUnit3 vs. JUnit4 behavior than I have included in my answer: http://stackoverflow.com/a/3660003/477451 – Mansoor Siddiqui Dec 13 '12 at 00:50
1

This doesn't quite answer the question. The long answer is correct for non-static fields, but data referenced from static fields are not garbage collected. See http://stackoverflow.com/a/453073/95725 – NamshubWriter Mar 27 '15 at 02:40
Right, I thought that was implied by my explanation, but maybe I wasn't entirely clear on that point? A static variable itself will never be collected (as per your link), but you can still elect the objects being pointed to by it for garbage collection by nulling out the static reference. – Mansoor Siddiqui Mar 27 '15 at 14:30
1

your short answer seems incorrect. You state in JUnit3 to nullify static members, but in JUnit4 this practice is not necessary. Digging through your long answer you discuss non-static members, not static members and digging through the comments on here, we find that static members should be nulled out even in JUnit4. Can you update your short answer to be more accurate? – Achilles929 Feb 05 '18 at 17:16
Good call @Achilles929 -- it took me a minute to understand what you were referring to, but indeed the short answer description was not correct. Thanks for pointing it out! – Mansoor Siddiqui Feb 07 '18 at 03:47

score 2 · Answer 2 · answered Dec 17 '12 at 19:17

Static variables stay in existance until the JVM terminates. If there is a reason to make it static (it's used by multiple tests and is costly to initializes) then feel free to do so, just clean them up when you are done with them.

For non-static, as others have said, JUnit will clean these up on its own.

score 0 · Answer 3 · answered Dec 08 '12 at 12:18

good tests don't have to clean after themselves. they should only prepare data. other tests shouldn't depend on those data. in practice sometimes you need to close database connection or clean up some other long term resources. however some purists would say in that case it's not unit test any more. if you work with badly designed legacy code sometimes you have to clean some static variables of framework you use (e.g spring SecurityContext). usually such code can be refactored to avoid such cleaning

Should I nullify static variables in AfterClass (Java JUnit 4)?

3 Answers3