From c05bf9383010916fae6dec98978d7124de00e801 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sun, 28 Mar 2010 21:29:03 -0400 Subject: [PATCH] fix annotations detection test --- compile/src/test/scala/ApplicationsTest.scala | 4 +-- .../src/test/scala/DetectAnnotations.scala | 31 +++++++++---------- compile/src/test/scala/DetectSubclasses.scala | 2 +- compile/src/test/scala/TestCompile.scala | 15 ++++----- 4 files changed, 26 insertions(+), 26 deletions(-) diff --git a/compile/src/test/scala/ApplicationsTest.scala b/compile/src/test/scala/ApplicationsTest.scala index b2c30a465..0dea907e4 100644 --- a/compile/src/test/scala/ApplicationsTest.scala +++ b/compile/src/test/scala/ApplicationsTest.scala @@ -104,12 +104,12 @@ object ApplicationsTest extends Specification "Analysis plugin should detect applications" in { WithFiles(sources : _*) { case files @ Seq(main, main2, main3, main4, main5, main6, main7, main8, main9, mainA, mainB, mainC, mainD, mainE, mainF) => for(scalaVersion <- TestCompile.allVersions) - CallbackTest(scalaVersion, files, Nil, Nil) { (callback, file, log) => + CallbackTest(scalaVersion, files, Nil, Nil) { (callback, file, scalaInstance, log) => val expected = Seq( main -> "Main", main4 -> "Main4", main8 -> "Main8", main9 -> "Main9", mainB -> "MainB", mainE -> "MainE1", mainE -> "MainE2", mainE -> "MainE3", mainE -> "MainE4", mainE -> "MainE5", mainF -> "MainF1", mainF -> "MainF2", mainF -> "MainF4") (callback.applications) must haveTheSameElementsAs(expected) - val loader = new URLClassLoader(Array(file.toURI.toURL), getClass.getClassLoader) + val loader = new URLClassLoader(Array(file.toURI.toURL), scalaInstance.loader) for( (_, className) <- expected) testRun(loader, className) } } diff --git a/compile/src/test/scala/DetectAnnotations.scala b/compile/src/test/scala/DetectAnnotations.scala index 20000fe52..d5bd5fbff 100644 --- a/compile/src/test/scala/DetectAnnotations.scala +++ b/compile/src/test/scala/DetectAnnotations.scala @@ -8,42 +8,41 @@ object DetectAnnotations extends Specification val sources = ("c/A.scala" -> "package c; class A(x: Int, y: Int) extends Annotation") :: ("B.scala" -> "class B extends Annotation") :: + ("d/C.scala" -> "package d; class C extends Annotation") :: ("a/Super1.scala" -> "package a; trait Super1") :: - ("a/Super2.scala" -> "package a; @A(3,4) trait Super2") :: - ("a/Super3.scala" -> "package a; @B class Super3") :: - ("a/Super4.scala" -> "package a; trait Super4 { @B def test = () }") :: - ("b/Middle.scala" -> "package y.w; trait Mid extends a.Super2 with a.Super3") :: - ("b/Sub1.scala" -> "package a; class Sub1 extends a.Super3 with y.w.Mid") :: + ("a/Super2.scala" -> "package a; @c.A(3,4) trait Super2") :: + ("Super3.scala" -> "@B class Super3") :: + ("a/Super4.scala" -> "package a; trait Super4 { @d.C def test = () }") :: + ("b/Middle.scala" -> "package y.w; trait Mid extends a.Super2") :: + ("b/Sub1.scala" -> "class Sub1 extends Super3 with y.w.Mid") :: ("b/Sub2.scala" -> "final class Sub2 extends a.Super1") :: - ("b/Sub3.scala" -> "@B @A(3,4) final class Sub3 extends a.Super1") :: + ("b/Sub3.scala" -> "@B @c.A(3,4) final class Sub3 extends a.Super1") :: ("d/Sub4.scala" -> "@B private class Sub4 extends a.Super1") :: ("d/Sub5.scala" -> "@B protected class Sub5 extends a.Super1") :: ("d/Sub6.scala" -> "@B abstract class Sub6 extends a.Super1") :: ("d/Sub7.scala" -> "class Sub7 extends a.Super4") :: - ("d/Sub8.scala" -> "class Sub8 { @A(5,6) def test(s: Int) = s }") :: + ("d/Sub8.scala" -> "class Sub8 { @c.A(5,6) def test(s: Int) = s }") :: ("d/Sub9.scala" -> "object Sub9 { @B def test(s: String) = s }") :: - ("d/SubA.scala" -> "object SubA { @A(3,3) def test = s }\nclass SubA { @B private def test = s }") :: - ("d/SubB.scala" -> "object SubB { @A(3,3) def test = s }\nclass SubB { @B def test = s }") :: + ("d/SubA.scala" -> "object SubA { @c.A(3,3) def test = () }\nclass SubA { @B private def test = 6 }") :: + ("d/SubB.scala" -> "object SubB { @c.A(3,3) def test = 3 }\nclass SubB { @d.C def test = () }") :: Nil "Analysis plugin should detect annotations" in { WithFiles(sources.map{case (file, content) => (new File(file), content)} : _*) { - case files @ Seq(sup1File, sup2File, sup3File, sup4File, midFile, sub1File, sub2File, sub3File, sub4File, sub5File, sub6File, sub7File, sub8File, sub9File, subAFile, subBFile) => + case files @ Seq(a, b, c, sup1File, sup2File, sup3File, sup4File, midFile, sub1File, sub2File, sub3File, sub4File, sub5File, sub6File, sub7File, sub8File, sub9File, subAFile, subBFile) => for(scalaVersion <- TestCompile.allVersions) - CallbackTest(scalaVersion, files, Nil, Seq("c.A", "B") ) { (callback, x, xx) => + CallbackTest(scalaVersion, files, Nil, Seq("c.A", "B", "d.C") ) { (callback, _, _, _) => val expected = - (sup3File, "a.Super3", "B", false) :: - (sub1File, "a.Sub1", "B", false) :: - (sub1File, "a.Sub1", "c.A", false) :: + (sup3File, "Super3", "B", false) :: (sub3File, "Sub3", "B", false) :: (sub3File, "Sub3", "c.A", false) :: - (sub7File, "Sub7", "B", false) :: + (sub7File, "Sub7", "d.C", false) :: (sub8File, "Sub8", "c.A", false) :: (sub9File, "Sub9", "B", true) :: (subAFile, "SubA", "c.A", true) :: (subBFile, "SubB", "c.A", true) :: - (subBFile, "SubB", "B", false) :: + (subBFile, "SubB", "d.C", false) :: Nil (callback.foundAnnotated) must haveTheSameElementsAs(expected) } diff --git a/compile/src/test/scala/DetectSubclasses.scala b/compile/src/test/scala/DetectSubclasses.scala index 33382c734..58e77f4b3 100644 --- a/compile/src/test/scala/DetectSubclasses.scala +++ b/compile/src/test/scala/DetectSubclasses.scala @@ -19,7 +19,7 @@ object DetectSubclasses extends Specification { case files @ Seq(supFile, sup2File, midFile, sub1File, sub2File, sub3File) => for(scalaVersion <- TestCompile.allVersions) - CallbackTest(scalaVersion, files, Seq( "a.Super", "Super2", "x.Super3", "Super4"), Nil ) { (callback, x, xx) => + CallbackTest(scalaVersion, files, Seq( "a.Super", "Super2", "x.Super3", "Super4"), Nil ) { (callback, _, _, _) => val expected = (sub1File, "a.Sub1", "a.Super", false) :: (sub2File, "Sub2", "a.Super", false) :: diff --git a/compile/src/test/scala/TestCompile.scala b/compile/src/test/scala/TestCompile.scala index 25f2495d9..b76d39f3d 100644 --- a/compile/src/test/scala/TestCompile.scala +++ b/compile/src/test/scala/TestCompile.scala @@ -8,28 +8,29 @@ import FileUtilities.withTemporaryDirectory object TestCompile { // skip 2.7.3 and 2.7.4 for speed - def allVersions = List("2.7.2", "2.7.5", "2.7.7", "2.8.0-SNAPSHOT", "2.8.0.Beta1")//List("2.7.2", "2.7.3", "2.7.4", "2.7.5", "2.8.0-SNAPSHOT") + def allVersions = List("2.7.2", "2.7.5", "2.7.7", "2.8.0.Beta1")//List("2.7.2", "2.7.3", "2.7.4", "2.7.5", "2.8.0-SNAPSHOT") /** Tests running the compiler interface with the analyzer plugin with a test callback. The test callback saves all information * that the plugin sends it for post-compile analysis by the provided function.*/ - def apply[T](scalaVersion: String, sources: Set[File], outputDirectory: File, options: Seq[String], superclassNames: Seq[String], annotationNames: Seq[String])(f: (TestCallback, CompileLogger) => T): T = + def apply[T](scalaVersion: String, sources: Set[File], outputDirectory: File, options: Seq[String], superclassNames: Seq[String], annotationNames: Seq[String]) + (f: (TestCallback, ScalaInstance, CompileLogger) => T): T = { val testCallback = new TestCallback(superclassNames.toArray, annotationNames.toArray) WithCompiler(scalaVersion) { (compiler, log) => compiler(sources, Set.empty, outputDirectory, options, testCallback, 5, log) - f(testCallback, log) + f(testCallback, compiler.scalaInstance, log) } } /** Tests running the compiler interface with the analyzer plugin. The provided function is given a ClassLoader that can * load the compiled classes..*/ def apply[T](scalaVersion: String, sources: Seq[File])(f: ClassLoader => T): T = - CallbackTest.apply(scalaVersion, sources, Nil, Nil){ case (callback, outputDir, log) => f(new URLClassLoader(Array(outputDir.toURI.toURL))) } + CallbackTest.apply(scalaVersion, sources, Nil, Nil){ case (_, outputDir, _, _) => f(new URLClassLoader(Array(outputDir.toURI.toURL))) } } object CallbackTest { def apply[T](scalaVersion: String, sources: Iterable[File])(f: TestCallback => T): T = - apply(scalaVersion, sources.toSeq, Nil, Nil){ case (callback, outputDir, log) => f(callback) } - def apply[T](scalaVersion: String, sources: Seq[File], superclassNames: Seq[String], annotationNames: Seq[String])(f: (TestCallback, File, CompileLogger) => T): T = + apply(scalaVersion, sources.toSeq, Nil, Nil){ case (callback, _, _, _) => f(callback) } + def apply[T](scalaVersion: String, sources: Seq[File], superclassNames: Seq[String], annotationNames: Seq[String])(f: (TestCallback, File, ScalaInstance, CompileLogger) => T): T = withTemporaryDirectory { outputDir => - TestCompile(scalaVersion, Set() ++ sources, outputDir, Nil, superclassNames, annotationNames) { case (callback, log) => f(callback, outputDir, log) } + TestCompile(scalaVersion, Set() ++ sources, outputDir, Nil, superclassNames, annotationNames) { case (callback, instance, log) => f(callback, outputDir, instance, log) } } } \ No newline at end of file