How do you implement @BeforeClass semantics in a JUnit 4 test written in scala?

I've inherited some JUnit tests written in scala that need to be fixed to use @BeforeClass semantics. I understand that the @BeforeClass annotation must be applied to static methods only. I understand that methods defined in "companion" objects (as opposed to scala classes) are static. How can I get a test开发者_运维知识库 method to be called once prior to the individual instance methods in a test class?

object TestClass {

  @BeforeClass
  def stuff() {
    // beforeclass stuff
  }

}

class TestClass {

  @Test
  ...

}

seems to work...

I had to move to specs2 to implement this feature with Scala. Just adding an example to help people with the same problem as the orginal poster who don't yet know specs2.

The specs2 way uses the concept of a "step" to accomplish test suite set-up and tear-down. If you run with a JUnitRunner all your Ant scripts and IDEs that use JUnit will still know how to run it. Here's an example using a mutable specification from specs2:

import org.specs2.mutable.Specification
import org.junit.runner.RunWith
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class MutableSpecs2ExampleTest extends Specification {

  var firstStep: String = null
  var secondStep: String = null
  var thirdStep: String = null
  //Steps are guaranteed to run serially
  step{println("Loading Spring application context...");firstStep="Hello World"}
  step{println("Setting up mocks...");secondStep = "Hello Scala"}

  //The fragments should be run in parallel by specs2
  "Some component Foo in my project" should{
    " pass these tests" in {
      println("Excersizing some code in Foo")
      firstStep must startWith("Hello") and endWith("World")
    }
    " pass theses other tests" in  {
      println("Excersizing some other code in Foo")
      firstStep must have size(11)
    }
  }
  "Some component Bar in my project" should{
    " give the correct answer" in {
      println("Bar is thinking...")
      secondStep must startWith("Hello") and endWith("Scala")
      thirdStep must be equalTo null
    }
  }
  step{println("Tearing down resources after tests...");thirdStep = "Hello Specs2"}
}

And here's an example with a non-mutable specification:

import org.specs2.Specification
import org.specs2.specification.Step
import org.junit.runner.RunWith
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class Specs2ExampleTest extends Specification{
  var firstStep: String = null
  var secondStep: String = null
  var thirdStep: String = null

  def is =
  "This is a test with some set-up and tear-down examples" ^
                                                           p^
    "Initialize"                                           ^
                                                           Step(initializeDependencies())^
                                                           Step(createTestData())^
    "Component Foo should"                                 ^
      "perform some calculation X "                        !testX^
      "perform some calculation Y"                         !testY^
                                                           p^
    "Tidy up"                                              ^
                                                           Step(removeTestData())^
                                                           end
    def testX = {
      println("testing Foo.X")
      firstStep must be equalTo("Hello World")
    }
    def testY = {
      println("testing Foo.Y")
      secondStep must be equalTo("Hello Scala")
      thirdStep must be equalTo null
    }

  def initializeDependencies(){
    println("Initializing Spring applicaiton context...")
    firstStep = "Hello World"
  }
  def createTestData(){
    println("Inserting test data into the db...")
    secondStep = "Hello Scala"
  }

  def removeTestData(){
    println("Removing test data from the db...")
    println("Tearing down resources...")
    thirdStep = "Hello Specs2"
  }
}

You don't specify if you mean inherited in the OO-programming sense or the "taken over from someone else" sense of the word.

In the latter case, I'd advise you to re-write the thing using either ScalaTest or Specs2 and expose it as a JUnit test (both frameworks support this) so that it'll integrate with whatever other tools and processes you already have in place.