From 4ffe9345ca6e611ff5a83a3fdabeb7658a2fce50 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Sun, 18 Jan 2015 23:22:25 +0100
Subject: Reuse the same compiler instance for all tests in a JUnit class

Note that JUnit creates a new instance of the test class for running
each test method. So the compiler instance is added to the companion.
However, the JVM would quickly run out of memory when running multiple
tests, as the compilers cannot be GCd. So we make it a `var`, and set
it to null when a class is done. For that we use JUnit's `@AfterClass`
which is required to be on a static method. Therefore we add a Java
class with such a static method that we can extend from Scala.
---
 .../scala/tools/nsc/backend/jvm/BTypesTest.scala   | 52 ++++++++++++----------
 1 file changed, 29 insertions(+), 23 deletions(-)

(limited to 'test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala')

diff --git a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala
index 2347e8288e..6ada0e20fb 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala
@@ -7,35 +7,41 @@ import org.junit.Test
 import scala.tools.asm.Opcodes
 import org.junit.Assert._
 
-@RunWith(classOf[JUnit4])
-class BTypesTest {
-  val settings = new Settings()
-  settings.processArgumentString("-usejavacp")
-  val g: Global = new Global(settings)
-  val run = new g.Run() // initializes some compiler internals
-  import g.{definitions => d, Symbol}
+import scala.tools.nsc.backend.jvm.CodeGenTools._
+import scala.tools.testing.ClearAfterClass
 
-  def duringBackend[T](f: => T) = g.exitingDelambdafy(f)
+object BTypesTest extends ClearAfterClass.Clearable {
+  var compiler = {
+    val comp = newCompiler(extraArgs = "-Ybackend:GenBCode -Yopt:l:none")
+    new comp.Run() // initializes some of the compiler
+    comp.exitingDelambdafy(comp.scalaPrimitives.init()) // needed: it's only done when running the backend, and we don't actually run the compiler
+    comp.exitingDelambdafy(comp.genBCode.bTypes.initializeCoreBTypes())
+    comp
+  }
+  def clear(): Unit = { compiler = null }
+}
 
-  val btypes = new BTypesFromSymbols[g.type](g)
-  import btypes._
-  duringBackend(btypes.initializeCoreBTypes())
+@RunWith(classOf[JUnit4])
+class BTypesTest extends ClearAfterClass {
+  ClearAfterClass.stateToClear = BTypesTest
 
-  def classBTypeFromSymbol(sym: Symbol) = duringBackend(btypes.classBTypeFromSymbol(sym))
+  val compiler = BTypesTest.compiler
+  import compiler.genBCode.bTypes._
 
-  val jlo = d.ObjectClass
-  val jls = d.StringClass
+  def classBTFS(sym: compiler.Symbol) = compiler.exitingDelambdafy(classBTypeFromSymbol(sym))
 
-  val o = classBTypeFromSymbol(jlo)
-  val s = classBTypeFromSymbol(jls)
-  val oArr = ArrayBType(o)
-  val method = MethodBType(List(oArr, INT, DOUBLE, s), UNIT)
+  def jlo = compiler.definitions.ObjectClass
+  def jls = compiler.definitions.StringClass
+  def o = classBTFS(jlo)
+  def s = classBTFS(jls)
+  def oArr = ArrayBType(o)
+  def method = MethodBType(List(oArr, INT, DOUBLE, s), UNIT)
 
   @Test
   def classBTypesEquality() {
-    val s1 = classBTypeFromSymbol(jls)
-    val s2 = classBTypeFromSymbol(jls)
-    val o  = classBTypeFromSymbol(jlo)
+    val s1 = classBTFS(jls)
+    val s2 = classBTFS(jls)
+    val o  = classBTFS(jlo)
     assertEquals(s1, s2)
     assertEquals(s1.hashCode, s2.hashCode)
     assert(s1 != o)
@@ -53,7 +59,7 @@ class BTypesTest {
     assert(FLOAT.typedOpcode(Opcodes.IALOAD)  == Opcodes.FALOAD)
     assert(LONG.typedOpcode(Opcodes.IALOAD)   == Opcodes.LALOAD)
     assert(DOUBLE.typedOpcode(Opcodes.IALOAD) == Opcodes.DALOAD)
-    assert(classBTypeFromSymbol(jls).typedOpcode(Opcodes.IALOAD) == Opcodes.AALOAD)
+    assert(classBTFS(jls).typedOpcode(Opcodes.IALOAD) == Opcodes.AALOAD)
 
     assert(UNIT.typedOpcode(Opcodes.IRETURN)   == Opcodes.RETURN)
     assert(BOOL.typedOpcode(Opcodes.IRETURN)   == Opcodes.IRETURN)
@@ -64,7 +70,7 @@ class BTypesTest {
     assert(FLOAT.typedOpcode(Opcodes.IRETURN)  == Opcodes.FRETURN)
     assert(LONG.typedOpcode(Opcodes.IRETURN)   == Opcodes.LRETURN)
     assert(DOUBLE.typedOpcode(Opcodes.IRETURN) == Opcodes.DRETURN)
-    assert(classBTypeFromSymbol(jls).typedOpcode(Opcodes.IRETURN)   == Opcodes.ARETURN)
+    assert(classBTFS(jls).typedOpcode(Opcodes.IRETURN)   == Opcodes.ARETURN)
   }
 
   @Test
-- 
cgit v1.2.3