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

Run the functional tests, to ensure they're correct

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 {}))
+  }
+}

functional-tests/src/test/abstract-class-inherits-new-abstract-class-with-abstract-method-nok/v1/A.scala

@@ -5,3 +5,6 @@ abstract class C extends B {
 }
 abstract class D extends C
 
+object Usage {
+  def use(a: A) = ()
+}

functional-tests/src/test/abstract-class-inherits-new-abstract-class-with-abstract-method-nok/v2/A.scala

@@ -8,3 +8,7 @@ abstract class C extends B {
   def foo(): Unit
 }
 abstract class D extends C
+
+object Usage {
+  def use(a: A) = a.foo()
+}

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

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

functional-tests/src/test/abstract-class-inherits-new-trait-with-abstract-method-nok/problems.txt

@@ -1,2 +1,2 @@
-abstract method foo()Unit in interface AA is inherited by class B in new version.
-abstract method foo()Unit in interface AA is inherited by class A in new version.
+abstract method foo()Int in interface AA is inherited by class A in new version.
+abstract method foo()Int in interface AA is inherited by class B in new version.

functional-tests/src/test/abstract-class-inherits-new-trait-with-abstract-method-nok/v1/A.scala

@@ -1,2 +1,7 @@
 trait A
-abstract class B
+abstract class B
+
+object Usage {
+  def useA(a: A) = 0
+  def useB(b: B) = 1
+}

functional-tests/src/test/abstract-class-inherits-new-trait-with-abstract-method-nok/v2/A.scala

@@ -1,6 +1,11 @@
 trait AA {
-  def foo(): Unit
+  def foo(): Int
 }
 
 trait A extends AA
 abstract class B extends A
+
+object Usage {
+  def useA(a: A) = a.foo() + 1
+  def useB(b: B) = b.foo() + 2
+}

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

@@ -0,0 +1,7 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    println(Usage.useA(new A {}) + 10)
+    println(Usage.useB(new B {}) + 11)
+    println(Usage.useC(new C {}) + 12)
+  }
+}

functional-tests/src/test/abstract-class-inherits-new-trait-with-abstract-method2-nok/v1/A.scala

@@ -2,3 +2,8 @@ trait A
 trait B
 abstract class C extends A with B
 
+object Usage {
+  def useA(a: A) = 0
+  def useB(b: B) = 0
+  def useC(c: C) = 0
+}

functional-tests/src/test/abstract-class-inherits-new-trait-with-abstract-method2-nok/v2/A.scala

@@ -4,3 +4,9 @@ trait AA {
 trait A extends AA
 trait B extends A
 abstract class C extends B
+
+object Usage {
+  def useA(a: A) = a.foo + 1
+  def useB(b: B) = b.foo + 2
+  def useC(c: C) = c.foo + 3
+}

functional-tests/src/test/added-abstract-class-in-new-version-ok/app/App.scala

@@ -0,0 +1,3 @@
+object App {
+  def main(args: Array[String]): Unit = () // v1 is (fundamentally) empty
+}

functional-tests/src/test/added-new-trait-with-abstract-methods-ok/app/App.scala

@@ -0,0 +1,3 @@
+object App {
+  def main(args: Array[String]): Unit = () // v1 is empty
+}

functional-tests/src/test/added-new-trait-with-concrete-methods-ok/app/App.scala

@@ -0,0 +1,3 @@
+object App {
+  def main(args: Array[String]): Unit = () // v1 is empty
+}

functional-tests/src/test/added-trait-in-new-version-ok/app/App.scala

@@ -0,0 +1,3 @@
+object App {
+  def main(args: Array[String]): Unit = () // v1 is (fundamentally) empty
+}

functional-tests/src/test/case-class-abstract-becomes-concrete-ok/app/App.scala

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

functional-tests/src/test/case-class-becomes-final-nok/app/App.scala

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

functional-tests/src/test/case-class-concrete-becomes-abstract-nok/app/App.scala

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

functional-tests/src/test/case-class-constructor-becomes-private-ok/app/App.scala

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

functional-tests/src/test/case-class-was-final-becomes-open-ok/app/App.scala

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

functional-tests/src/test/class-abstract-becomes-concrete-ok/app/App.scala

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

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

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

functional-tests/src/test/class-added-class-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-added-local-class-ok/app/App.scala

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

functional-tests/src/test/class-added-local-method-ok/app/App.scala

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

functional-tests/src/test/class-added-method-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-added-same-class-in-different-package-is-ok/app/App.scala

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

functional-tests/src/test/class-added-val-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-added-var-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-becomes-final-nok/app/App.scala

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

functional-tests/src/test/class-becomes-object-nok/app/App.scala

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

functional-tests/src/test/class-becomes-trait-nok/app/App.scala

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

functional-tests/src/test/class-changed-local-class-ok/app/App.scala

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

functional-tests/src/test/class-changed-method-with-val-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-changed-method-with-var-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-changed-val-type-in-new-version-nok/app/App.scala

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

functional-tests/src/test/class-changed-val-with-method-in-new-version-ok/app/App.scala

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

functional-tests/src/test/class-changed-var-type-in-new-version-nok/app/App.scala

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