luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix annotations detection test

This commit is contained in:
Mark Harrah 2010-03-28 21:29:03 -04:00
parent b26ca870b1
commit c05bf93830
4 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compile/src/test/scala/ApplicationsTest.scala
View File

@ -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)
}
}

31
compile/src/test/scala/DetectAnnotations.scala
View File

@ -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)
}

2
compile/src/test/scala/DetectSubclasses.scala
View File

@ -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) ::

15
compile/src/test/scala/TestCompile.scala
View File

@ -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) }
}
}