1 files changed, 22 insertions, 25 deletions
diff --git a/test/junit/scala/tools/nsc/backend/jvm/analysis/NullnessAnalyzerTest.scala b/test/junit/scala/tools/nsc/backend/jvm/analysis/NullnessAnalyzerTest.scala
index d37adb2265..358a461026 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/analysis/NullnessAnalyzerTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/analysis/NullnessAnalyzerTest.scala
@@ -2,29 +2,26 @@ package scala.tools.nsc
 package backend.jvm
 package analysis
 
+import org.junit.Assert._
+import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
-import org.junit.Test
-import scala.tools.asm.Opcodes._
-import org.junit.Assert._
 
-import scala.tools.testing.BytecodeTesting._
-import scala.tools.asm.tree.{AbstractInsnNode, MethodNode}
+import scala.collection.JavaConverters._
+import scala.tools.asm.tree.MethodNode
+import scala.tools.nsc.backend.jvm.AsmUtils._
 import scala.tools.nsc.backend.jvm.BTypes._
-import scala.tools.partest.ASMConverters
-import ASMConverters._
-import scala.tools.testing.ClearAfterClass
 import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
-import AsmUtils._
-
-import scala.collection.JavaConverters._
+import scala.tools.testing.BytecodeTesting
+import scala.tools.testing.BytecodeTesting._
 
 @RunWith(classOf[JUnit4])
-class NullnessAnalyzerTest extends ClearAfterClass {
-  val noOptCompiler = cached("noOptCompiler", () => newCompiler(extraArgs = "-Yopt:l:none"))
-  import noOptCompiler.genBCode.bTypes.backendUtils._
+class NullnessAnalyzerTest extends BytecodeTesting {
+  override def compilerArgs = "-Yopt:l:none"
+  import compiler._
+  import global.genBCode.bTypes.backendUtils._
 
-  def newNullnessAnalyzer(methodNode: MethodNode, classInternalName: InternalName = "C") = new AsmAnalyzer(methodNode, classInternalName, new NullnessAnalyzer(noOptCompiler.genBCode.bTypes))
+  def newNullnessAnalyzer(methodNode: MethodNode, classInternalName: InternalName = "C") = new AsmAnalyzer(methodNode, classInternalName, new NullnessAnalyzer(global.genBCode.bTypes))
 
   def testNullness(analyzer: AsmAnalyzer[NullnessValue], method: MethodNode, query: String, index: Int, nullness: NullnessValue): Unit = {
     for (i <- findInstr(method, query)) {
@@ -53,7 +50,7 @@ class NullnessAnalyzerTest extends ClearAfterClass {
 
   @Test
   def showNullnessFramesTest(): Unit = {
-    val List(m) = compileMethods(noOptCompiler)("def f = this.toString")
+    val List(m) = compileMethods("def f = this.toString")
 
     // NOTE: the frame for an instruction represents the state *before* executing that instr.
     // So in the frame for `ALOAD 0`, the stack is still empty.
@@ -71,14 +68,14 @@ class NullnessAnalyzerTest extends ClearAfterClass {
 
   @Test
   def thisNonNull(): Unit = {
-    val List(m) = compileMethods(noOptCompiler)("def f = this.toString")
+    val List(m) = compileMethods("def f = this.toString")
     val a = newNullnessAnalyzer(m)
     testNullness(a, m, "ALOAD 0", 0, NotNullValue)
   }
 
   @Test
   def instanceMethodCall(): Unit = {
-    val List(m) = compileMethods(noOptCompiler)("def f(a: String) = a.trim")
+    val List(m) = compileMethods("def f(a: String) = a.trim")
     val a = newNullnessAnalyzer(m)
     testNullness(a, m, "INVOKEVIRTUAL java/lang/String.trim", 1, UnknownValue1)
     testNullness(a, m, "ARETURN", 1, NotNullValue)
@@ -86,7 +83,7 @@ class NullnessAnalyzerTest extends ClearAfterClass {
 
   @Test
   def constructorCall(): Unit = {
-    val List(m) = compileMethods(noOptCompiler)("def f = { val a = new Object; a.toString }")
+    val List(m) = compileMethods("def f = { val a = new Object; a.toString }")
     val a = newNullnessAnalyzer(m)
 
     // for reference, the output of showAllNullnessFrames(a, m) - note that the frame represents the state *before* executing the instr.
@@ -111,7 +108,7 @@ class NullnessAnalyzerTest extends ClearAfterClass {
 
   @Test
   def explicitNull(): Unit = {
-    val List(m) = compileMethods(noOptCompiler)("def f = { var a: Object = null; a }")
+    val List(m) = compileMethods("def f = { var a: Object = null; a }")
     val a = newNullnessAnalyzer(m)
     for ((insn, index, nullness) <- List(
       ("+ACONST_NULL", 2, NullValue),
@@ -122,14 +119,14 @@ class NullnessAnalyzerTest extends ClearAfterClass {
 
   @Test
   def stringLiteralsNotNull(): Unit = {
-    val List(m) = compileMethods(noOptCompiler)("""def f = { val a = "hi"; a.trim }""")
+    val List(m) = compileMethods("""def f = { val a = "hi"; a.trim }""")
     val a = newNullnessAnalyzer(m)
     testNullness(a, m, "+ASTORE 1", 1, NotNullValue)
   }
 
   @Test
   def newArraynotNull() {
-    val List(m) = compileMethods(noOptCompiler)("def f = { val a = new Array[Int](2); a(0) }")
+    val List(m) = compileMethods("def f = { val a = new Array[Int](2); a(0) }")
     val a = newNullnessAnalyzer(m)
     testNullness(a, m, "+NEWARRAY T_INT", 2, NotNullValue) // new array on stack
     testNullness(a, m, "+ASTORE 1", 1, NotNullValue)       // local var (a)
@@ -147,7 +144,7 @@ class NullnessAnalyzerTest extends ClearAfterClass {
         |  a.toString
         |}
       """.stripMargin
-    val List(m) = compileMethods(noOptCompiler)(code)
+    val List(m) = compileMethods(code)
     val a = newNullnessAnalyzer(m)
     val toSt = "+INVOKEVIRTUAL java/lang/Object.toString"
     testNullness(a, m, toSt, 3, UnknownValue1)
@@ -173,7 +170,7 @@ class NullnessAnalyzerTest extends ClearAfterClass {
         |  // d is null here, assinged in both branches.
         |}
       """.stripMargin
-    val List(m) = compileMethods(noOptCompiler)(code)
+    val List(m) = compileMethods(code)
     val a = newNullnessAnalyzer(m)
 
     val trim = "INVOKEVIRTUAL java/lang/String.trim"
@@ -209,7 +206,7 @@ class NullnessAnalyzerTest extends ClearAfterClass {
         |  a.asInstanceOf[String].trim  // the stack value (LOAD of local a) is still not-null after the CHECKCAST
         |}
       """.stripMargin
-    val List(m) = compileMethods(noOptCompiler)(code)
+    val List(m) = compileMethods(code)
     val a = newNullnessAnalyzer(m)
 
     val instof = "+INSTANCEOF"