@BeforeClass: Difference between revisions
(10 intermediate revisions by the same user not shown) | |||
Line 2: | Line 2: | ||
* [[JUnit#Annotations|JUnit]] | * [[JUnit#Annotations|JUnit]] | ||
* [[@AfterClass]] | |||
=Overview= | =Overview= | ||
The annotation must be attached to a '''static''' method. | The annotation must be attached to a '''static''' method. | ||
=<tt>@BeforeClass</tt> and Class Hierarchies= | |||
If two methods '''with different names''' are annotated with <code>@BeforeClass</code> in a test class hierarchy, as shown below: | If two methods '''with different names''' are annotated with <code>@BeforeClass</code> in a test class hierarchy, as shown below: | ||
Line 12: | Line 15: | ||
TestBase.java | TestBase.java | ||
│ @BeforeClass | │ @BeforeClass | ||
│ public static void | │ public static void testBaseOneTimeSetup() { | ||
│ ... | |||
│ } | |||
│ | |||
└── SomeTest.java | |||
@BeforeClass | |||
public static void someTestOneTimeSetup() { | |||
... | |||
} | |||
</font> | |||
then both methods are executed only once, in this order: first the parent class method (<code>testBaseOneTimeSetup()</code>), then the subclass method (<code>someTestOneTimeSetup()</code>). The rule holds true in a multi-layer hierarchy. | |||
However, if both methods '''have the same name''', an override of sorts takes place and only the method belonging to the subclass is executed: | |||
<font size='-1'> | |||
TestBase.java | |||
│ @BeforeClass | |||
│ public static void oneTimeClassSetup() { | |||
│ ... | │ ... | ||
│ } | │ } | ||
│ | │ | ||
└── SomeTest.java | └── SomeTest.java | ||
@BeforeClass | |||
public static void oneTimeClassSetup() { | |||
... | |||
} | |||
</font> | |||
Only <code>SomeTest.oneTimeClassSetup()</code> (the most specific subclass) is executed, so if you need the logic executed in superclass, it must be invoked explicitly with: | |||
<syntaxhighlight lang='java'> | |||
class SomeTest { | |||
@BeforeClass | |||
public static void oneTimeClassSetup() { | |||
TestBase.oneTimeClassSetup(); | |||
} | |||
} | |||
</syntaxhighlight> | |||
This behavior is useful when we want to customize static fields in subclass, then execute the <code>@BeforeClass</code> superclass behavior. | |||
</ | In conclusion, if class-level one-time initialization is needed for each level of a class hierarchy, the best solution is to name <code>@BeforeClass</code> methods differently for each class. This way, all methods are executed in order, starting from the root of the hierarchy and continuing towards the bottom, ending with the most specific subclass. If customization of static fields is required in subclass, annotated same-name methods with <code>@BeforeClass</code> both in superclass and subclass. | ||
Recommended naming convention: | |||
<syntaxhighlight lang='java'> | |||
class SomeTest { | |||
@BeforeClass | |||
public static void someTestOneTimeSetup() { | |||
... | |||
} | |||
} | |||
</syntaxhighlight> |
Latest revision as of 23:11, 31 August 2021
Internal
Overview
The annotation must be attached to a static method.
@BeforeClass and Class Hierarchies
If two methods with different names are annotated with @BeforeClass
in a test class hierarchy, as shown below:
TestBase.java │ @BeforeClass │ public static void testBaseOneTimeSetup() { │ ... │ } │ └── SomeTest.java @BeforeClass public static void someTestOneTimeSetup() { ... }
then both methods are executed only once, in this order: first the parent class method (testBaseOneTimeSetup()
), then the subclass method (someTestOneTimeSetup()
). The rule holds true in a multi-layer hierarchy.
However, if both methods have the same name, an override of sorts takes place and only the method belonging to the subclass is executed:
TestBase.java │ @BeforeClass │ public static void oneTimeClassSetup() { │ ... │ } │ └── SomeTest.java @BeforeClass public static void oneTimeClassSetup() { ... }
Only SomeTest.oneTimeClassSetup()
(the most specific subclass) is executed, so if you need the logic executed in superclass, it must be invoked explicitly with:
class SomeTest {
@BeforeClass
public static void oneTimeClassSetup() {
TestBase.oneTimeClassSetup();
}
}
This behavior is useful when we want to customize static fields in subclass, then execute the @BeforeClass
superclass behavior.
In conclusion, if class-level one-time initialization is needed for each level of a class hierarchy, the best solution is to name @BeforeClass
methods differently for each class. This way, all methods are executed in order, starting from the root of the hierarchy and continuing towards the bottom, ending with the most specific subclass. If customization of static fields is required in subclass, annotated same-name methods with @BeforeClass
both in superclass and subclass.
Recommended naming convention:
class SomeTest {
@BeforeClass
public static void someTestOneTimeSetup() {
...
}
}