Run the functional tests, to ensure they're correct (#444)

Run the functional tests, to ensure they're correct

Author: dwijnand

core/src/main/scala/com/typesafe/tools/mima/lib/analyze/method/MethodChecker.scala

@@ -13,7 +13,7 @@ private[analyze] object MethodChecker {
 
   /** Analyze incompatibilities that may derive from new methods in `newclazz`. */
   private def checkNew(oldclazz: ClassInfo, newclazz: ClassInfo): List[Problem] = {
-    checkEmulatedConcreteMethodsProblems(oldclazz, newclazz) :::
+    (if (newclazz.isClass) Nil else checkEmulatedConcreteMethodsProblems(oldclazz, newclazz)) :::
       checkDeferredMethodsProblems(oldclazz, newclazz) :::
       checkInheritedNewAbstractMethodProblems(oldclazz, newclazz)
   }
@@ -108,30 +108,28 @@ private[analyze] object MethodChecker {
     methods.groupBy(_.parametersDesc).values.collect { case method :: _ => method }.toList
 
   private def checkEmulatedConcreteMethodsProblems(oldclazz: ClassInfo, newclazz: ClassInfo): List[Problem] = {
-    if (oldclazz.isClass && newclazz.isClass) Nil else {
-      for {
-        newmeth <- newclazz.emulatedConcreteMethods.iterator
-        if !oldclazz.hasStaticImpl(newmeth)
-        problem <- {
-          if (oldclazz.lookupMethods(newmeth).exists(_.descriptor == newmeth.descriptor)) {
-            // a static implementation for the same method existed already, therefore
-            // class that mixed-in the trait already have a forwarder to the implementation
-            // class. Mind that, despite no binary incompatibility arises, program's
-            // semantic may be severely affected.
-            None
-          } else {
-            // this means that the method is brand new and therefore the implementation
-            // has to be injected
-            Some(ReversedMissingMethodProblem(newmeth))
-          }
+    for {
+      newmeth <- newclazz.emulatedConcreteMethods.iterator
+      if !oldclazz.hasStaticImpl(newmeth)
+      problem <- {
+        if (oldclazz.lookupMethods(newmeth).exists(_.descriptor == newmeth.descriptor)) {
+          // a static implementation for the same method existed already, therefore
+          // classes that mixed-in the trait already have a forwarder to the implementation
+          // class. Mind that, despite no binary incompatibility arises, program's
+          // semantic may be severely affected.
+          None
+        } else {
+          // this means that the method is brand new
+          // and therefore the implementation has to be injected
+          Some(ReversedMissingMethodProblem(newmeth))
         }
-      } yield problem
-    }.toList
-  }
+      }
+    } yield problem
+  }.toList
 
   private def checkDeferredMethodsProblems(oldclazz: ClassInfo, newclazz: ClassInfo): List[Problem] = {
     for {
-      newmeth <- newclazz.deferredMethods
+      newmeth <- newclazz.deferredMethods.iterator
       problem <- oldclazz.lookupMethods(newmeth).find(_.descriptor == newmeth.descriptor) match {
         case None          => Some(ReversedMissingMethodProblem(newmeth))
         case Some(oldmeth) =>
@@ -140,7 +138,7 @@ private[analyze] object MethodChecker {
           else None
       }
     } yield problem
-  }
+  }.toList
 
   private def checkInheritedNewAbstractMethodProblems(oldclazz: ClassInfo, newclazz: ClassInfo): List[Problem] = {
     def allInheritedTypes(clazz: ClassInfo) = clazz.superClasses ++ clazz.allInterfaces

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/CollectProblemsTest.scala

@@ -11,7 +11,7 @@ import scala.tools.nsc.classpath.AggregateClassPath
 object CollectProblemsTest {
 
   // Called via reflection from TestsPlugin
-  def runTest(testClasspath: Array[File], testName: String, oldJarOrDir: File, newJarOrDir: File, baseDir: File, scalaVersion: String): Unit = {
+  def runTest(testClasspath: Array[File], testName: String, oldJarOrDir: File, newJarOrDir: File, baseDir: File, oracleFile: File): Unit = {
     val testClassPath = aggregateClassPath(testClasspath)
     val classpath = AggregateClassPath.createAggregate(testClassPath, Config.baseClassPath)
     val mima = new MiMaLib(classpath)
@@ -25,16 +25,6 @@ object CollectProblemsTest {
     val problems = mima.collectProblems(oldJarOrDir, newJarOrDir).filter(problemFilter)
 
     // load oracle
-    val oracleFile = {
-      val p = new File(baseDir, "problems.txt")
-      val p211 = new File(baseDir, "problems-2.11.txt")
-      val p212 = new File(baseDir, "problems-2.12.txt")
-      scalaVersion.take(4) match {
-        case "2.11" => if (p211.exists()) p211 else if (p212.exists()) p212 else p
-        case "2.12" => if (p212.exists()) p212 else p
-        case _      => p
-      }
-    }
     val source = Source.fromFile(oracleFile)
     val expectedProblems = try source.getLines.filter(!_.startsWith("#")).toList finally source.close()
 

functional-tests/src/test/abstract-class-added-abstract-method-nok/app/App.scala

@@ -0,0 +1,5 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(Usage.use(new A {}))
+  }
+}

functional-tests/src/test/abstract-class-added-abstract-method-nok/v1/A.scala

@@ -1 +1,5 @@
-abstract class A
+abstract class A
+
+object Usage {
+  def use(a: A) = ()
+}

functional-tests/src/test/abstract-class-added-abstract-method-nok/v2/A.scala

@@ -1,3 +1,7 @@
 abstract class A {
   def foo(): Unit
 }
+
+object Usage {
+  def use(a: A) = a.foo()
+}

functional-tests/src/test/abstract-class-extending-new-abstract-class-with-abstract-method-nok/app/App.scala

@@ -0,0 +1,10 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(new A {}.foo(new A {}))
+    println(new C)
+    println(new D)
+
+    println(new E { def bar(): E = new E { def bar() = this } }.bar())
+    println(new F)
+  }
+}

functional-tests/src/test/abstract-class-extending-new-trait-with-abstract-method-nok/app/App.scala

@@ -0,0 +1,5 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(new A {}.foo(new A {}))
+  }
+}

functional-tests/src/test/abstract-class-extending-new-trait-with-abstract-method-ok/app/App.scala

@@ -0,0 +1,5 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(new A { def foo = () }.foo)
+  }
+}

functional-tests/src/test/abstract-class-extending-new-trait-with-concrete-method-ok/app/App.scala

@@ -0,0 +1,5 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(new A {}.foo(new A {}))
+  }
+}

functional-tests/src/test/abstract-class-inherits-new-abstract-class-with-abstract-method-nok/app/App.scala

@@ -0,0 +1,6 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(Usage.use(new A {}))
+    println(Usage.use(new B {}))
+  }
+}