Add Before and After Parameterized Run annotations

[bigmikef]

Currently there is no simple way for a method to be invoked before or after a Parameterized instance is ran.

Said another way, along with @BeforeClass and @afterclass there should be @BeforeParameterRun @AfterParameterRun. Each fires before/after a Parameterized instance is ran.

[Yishai]

How about a parameter on the @before annotation itself: @before(true) or @before(onEachParameter = true). Defaulted to false, of course.

[bigmikef]

The goal of this request is to have a place to put code that runs before and after a parameter run executes. Not before each test in a given parameter run. Thus the order would be BP BT T1p1 AT BT T2p1 AT BT T3p1 AT AP BP BT T1p2 AT BT T2p2 AT ... where

• BP is the before parameter run method @BeforeParameterRun
• BT is the before test method @before
• Txpy is the xth test, on Parameter y @test eg T2P3 is test 2 on parameter 3
• AT is the after test method @after
• AP is the after parameter run @AfterParameterRun

I had this implemented on my github, however had to take it down due to issues with my employer. I issued a pull to David Saff and he included it in his branch, but it was taken out later. I'll look for the revision number where the code was included after this message.

[bigmikef]

Looks like the merge was to a tree of dsaff around April 3, 2009. In the comments you can see a merge from bigmikef. It is way out of date, but did work at the time.

[alexeyOnGitHub]

guys, "after / before" for every parameterized run would be very useful.

[matthewfarwell]

This can be done using rules, in particular ExternalResource. The implemented methods are called for each parameter:

@RunWith(Parameterized.class)
public class ParameterRuleTest {
    @Parameters()
    public static Iterable<Object[]> data() {
        return Arrays.asList(new Object[]{}, new Object[]{});
    }

    @Rule
    public ExternalResource externalResource = new ExternalResource() {
        protected void before() throws Throwable { System.out.println("before"); }
        protected void after() { System.out.println("after"); }
    };

    @Test public void myTest1() { System.out.println("test"); }
}

This produces

before
test
after
before
test
after

If this is acceptable, please close this issue.

[coreyjv]

@matthewfarwell I may be misunderstanding your response, but in the example you provided that rule would run before and after each test for each instance created by the parameterized runner.

What I think @bigmikef wanted was the capability to be able to run a before and after method once for each instance created by the parameterized runner. I don't think @ClassRule can be used in this case because that runs in a static context and is only executed once for all parameterized instances.

[coreyjv]

I wouldn't mind taking the initiative to implement this since it would be beneficial in my current project. My proposal is below:

Summary of Implementation:

The traditional architecture of JUnit is a instance of a Java class per test method. In order to implement the requirements above I believe the Parameterized runner needs to be modified to create one Java instance for each parameterized instance.

The primary reason for this is so the logic executed before and after each parameterized run is local to the class and not put in some global scope with a static modifier. In my particular use case I have setup and tear down that would require use of parameters that are unique to each parameterized instance.

Additions / Modifications:

org.junit.runners.Parameterized

• Add a new annotation named ParameterRule.
• Add a new protected inner class that extends TestClassRunnerForParameters named something like SingleInstanceRunnerForParameters.
• Instantiate TestClassRunnerForParameters or SingleInstanceRunnerForParameters depending if ParameterRule exists or not.

org.junit.runners.BlockJUnit4ClassRunner

• Move the creation of the test object out of methodBlock. Provide the test object as a parameter instead.
  • The main reason for this is so extended classes could pass their own instance into methodBlock. Otherwise if someone wants to extend BlockJUnit4ClassRunner and keep most of the functionality they have to copy the following methods: withRules, withMethodRules, withTestRules and getMethodRules
• If moving the creation of the test object out of methodBlock is not acceptable then changing the following methods from private to protected would reduce duplication of code:
  • withRules
  • withMethodRules
  • withTestRules
  • getMethodRules

org.junit.runners.Parameterized.SingleInstanceRunnerForParameters

• Add a method named withParameterRules that would execute rules annotated by ParameterRule.
• Execute withParameterRules in an overridden version of classBlock

If there is a preference to provide an example of this implementation I can on my fork, but I wanted to discuss the design before I invested a significant amount of time.

[Tibor17]

@coreyjv what's wrong with @matthewfarwell `s answer?

[coreyjv]

@Tibor17 , see my response to his answer: https://github.com/KentBeck/junit/issues/45#issuecomment-11293228

His implementation is executed before and after each test method. In my case, my setup and tear down is significantly expensive which is why I want to execute it before and after each parameterized run.

For example if I have a test class that when executed once with a common setup (located in a @ClassRule currently) the entire class executes and completes the tests in ~20 seconds. However, if I move the setup to a method level rule it takes approximately ~240 seconds to execute and complete. That's just for one class. In my situation that increase in time is not acceptable.

Theoretically I could place all my tests in a single method to emulate the required behavior but I don't think that is a maintainable test design.

[coreyjv]

@Tibor17, I'm not sure if notifications go out on updates so I thought I'd another comment.

@dsaff, any thoughts on this proposal?

[Tibor17]

@coreyjv
Basically what you want is something like @BeforeParams and @AfterParams executed only once in lifecycle. Am I right?

[coreyjv]

@Tibor17, essentially yes. I think I'd use a single annotation that allowed rules to execute.

[Tibor17]

If I used the BeforeClass (BC) and AC, then would it look like this ?
BC BP BT T1p1 AT BT T2p1 AT BT T3p1 AT AP BP BT T1p2 AT BT T2p2 AT AC

[coreyjv]

@Tibor17, yes I believe what you've presented is accurate.

[Tibor17]

@coreyjv
I think this feature you want might be interesting. What is your real use case?