1 files changed, 18 insertions, 38 deletions
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
index 6dd0a33289..f0913f3631 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
@@ -2,41 +2,21 @@ package scala.tools.nsc
 package backend.jvm
 package opt
 
+import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
-import org.junit.Test
-import scala.collection.generic.Clearable
-import scala.collection.mutable.ListBuffer
-import scala.reflect.internal.util.BatchSourceFile
-import scala.tools.asm.Opcodes._
-import org.junit.Assert._
-
-import scala.tools.asm.tree._
-import scala.tools.asm.tree.analysis._
-import scala.tools.nsc.io._
-import scala.tools.nsc.reporters.StoreReporter
-import scala.tools.testing.AssertUtil._
 
-import CodeGenTools._
-import scala.tools.partest.ASMConverters
-import ASMConverters._
-import AsmUtils._
+import scala.tools.testing.BytecodeTesting
+import scala.tools.testing.BytecodeTesting._
 
-import BackendReporting._
+@RunWith(classOf[JUnit4])
+class InlineWarningTest extends BytecodeTesting {
+  def optCp = "-Yopt:l:classpath"
+  override def compilerArgs = s"$optCp -Yopt-warnings"
 
-import scala.collection.JavaConverters._
-import scala.tools.testing.ClearAfterClass
+  import compiler._
 
-@RunWith(classOf[JUnit4])
-class InlineWarningTest extends ClearAfterClass {
-  val argsNoWarn = "-Yopt:l:classpath"
-  val args = argsNoWarn + " -Yopt-warnings"
-  val compiler = cached("compiler", () => newCompiler(extraArgs = args))
-  val compilerWarnAll = cached("compilerWarnAll", () => newCompiler(extraArgs = argsNoWarn + " -Yopt-warnings:_"))
-
-  def compile(scalaCode: String, javaCode: List[(String, String)] = Nil, allowMessage: StoreReporter#Info => Boolean = _ => false, compiler: Global = compiler): List[ClassNode] = {
-    compileClasses(compiler)(scalaCode, javaCode, allowMessage)
-  }
+  val compilerWarnAll = cached("compilerWarnAll", () => newCompiler(extraArgs = s"$optCp -Yopt-warnings:_"))
 
   @Test
   def nonFinal(): Unit = {
@@ -58,7 +38,7 @@ class InlineWarningTest extends ClearAfterClass {
       "C::m1()I is annotated @inline but cannot be inlined: the method is not final and may be overridden",
       "T::m2()I is annotated @inline but cannot be inlined: the method is not final and may be overridden",
       "D::m2()I is annotated @inline but cannot be inlined: the method is not final and may be overridden")
-    compile(code, allowMessage = i => {count += 1; warns.exists(i.msg contains _)})
+    compileToBytes(code, allowMessage = i => {count += 1; warns.exists(i.msg contains _)})
     assert(count == 4, count)
   }
 
@@ -73,7 +53,7 @@ class InlineWarningTest extends ClearAfterClass {
       """.stripMargin
 
     var c = 0
-    compile(code, allowMessage = i => {c += 1; i.msg contains "operand stack at the callsite in C::t1()V contains more values"})
+    compileToBytes(code, allowMessage = i => {c += 1; i.msg contains "operand stack at the callsite in C::t1()V contains more values"})
     assert(c == 1, c)
   }
 
@@ -103,14 +83,14 @@ class InlineWarningTest extends ClearAfterClass {
         |Note that the parent class A is defined in a Java source (mixed compilation), no bytecode is available.""".stripMargin)
 
     var c = 0
-    val List(b) = compile(scalaCode, List((javaCode, "A.java")), allowMessage = i => {c += 1; warns.tail.exists(i.msg contains _)})
+    val List(b) = compileToBytes(scalaCode, List((javaCode, "A.java")), allowMessage = i => {c += 1; warns.tail.exists(i.msg contains _)})
     assert(c == 1, c)
 
     // no warnings here
-    compileClasses(newCompiler(extraArgs = argsNoWarn + " -Yopt-warnings:none"))(scalaCode, List((javaCode, "A.java")))
+    newCompiler(extraArgs = s"$optCp -Yopt-warnings:none").compileToBytes(scalaCode, List((javaCode, "A.java")))
 
     c = 0
-    compileClasses(newCompiler(extraArgs = argsNoWarn + " -Yopt-warnings:no-inline-mixed"))(scalaCode, List((javaCode, "A.java")), allowMessage = i => {c += 1; warns.exists(i.msg contains _)})
+    newCompiler(extraArgs = s"$optCp -Yopt-warnings:no-inline-mixed").compileToBytes(scalaCode, List((javaCode, "A.java")), allowMessage = i => {c += 1; warns.exists(i.msg contains _)})
     assert(c == 2, c)
   }
 
@@ -137,7 +117,7 @@ class InlineWarningTest extends ClearAfterClass {
         |that would cause an IllegalAccessError when inlined into class N""".stripMargin
 
     var c = 0
-    compile(code, allowMessage = i => { c += 1; i.msg contains warn })
+    compileToBytes(code, allowMessage = i => { c += 1; i.msg contains warn })
     assert(c == 1, c)
   }
 
@@ -156,7 +136,7 @@ class InlineWarningTest extends ClearAfterClass {
         |  def t(a: M) = a.f(x => x + 1)
         |}
       """.stripMargin
-    compile(code, allowMessage = _ => false) // no warnings allowed
+    compileToBytes(code, allowMessage = _ => false) // no warnings allowed
 
     val warn =
       """M::f(Lscala/Function1;)I could not be inlined:
@@ -164,7 +144,7 @@ class InlineWarningTest extends ClearAfterClass {
         |that would cause an IllegalAccessError when inlined into class N""".stripMargin
 
     var c = 0
-    compile(code, compiler = compilerWarnAll, allowMessage = i => { c += 1; i.msg contains warn })
+    compilerWarnAll.compileToBytes(code, allowMessage = i => { c += 1; i.msg contains warn })
     assert(c == 1, c)
   }
 
@@ -185,7 +165,7 @@ class InlineWarningTest extends ClearAfterClass {
         |does not have the same strictfp mode as the callee C::f()I.""".stripMargin
 
     var c = 0
-    compile(code, allowMessage = i => { c += 1; i.msg contains warn })
+    compileToBytes(code, allowMessage = i => { c += 1; i.msg contains warn })
     assert(c == 1, c)
   }
 }