mirror of https://github.com/sbt/sbt.git
drop compilation tests
1. overlapped with integration tests 2. slower than integration tests 3. more fragile than integration tests
This commit is contained in:
Mark Harrah
parent
e2b5ce374c
commit
3f12f2eb9f
|
|
@ -1,142 +0,0 @@
|
||||||
package xsbt.api
|
|
||||||
|
|
||||||
import java.io.File
|
|
||||||
import java.net.URLClassLoader
|
|
||||||
import org.specs.Specification
|
|
||||||
import sbt.WithFiles
|
|
||||||
import sbt.compiler.{CallbackTest,TestCompile}
|
|
||||||
|
|
||||||
/** Verifies that the analyzer plugin properly detects main methods. The main method must be
|
|
||||||
* public with the right signature and be defined on a public, top-level module.*/
|
|
||||||
object ApplicationsTest extends Specification
|
|
||||||
{
|
|
||||||
val sourceContent =
|
|
||||||
"""
|
|
||||||
object Main { def main(args: Array[String]) {} }
|
|
||||||
""" :: """
|
|
||||||
class Main2 { def main(args: Array[String]) {} }
|
|
||||||
""" :: """
|
|
||||||
object Main3 { private def main(args: Array[String]) {} }
|
|
||||||
private object Main3b extends Main2
|
|
||||||
object Main3c { private def main(args: Array[String]) {} }
|
|
||||||
protected object Main3d { def main(args: Array[String]) {} }
|
|
||||||
object Main3e {
|
|
||||||
protected def main(args: Array[String]) {}
|
|
||||||
}
|
|
||||||
package a {
|
|
||||||
object Main3f { private[a] def main(args: Array[String]) {} }
|
|
||||||
object Main3g { protected[a] def main(args: Array[String]) {} }
|
|
||||||
}
|
|
||||||
""" ::"""
|
|
||||||
object Main4 extends Main2
|
|
||||||
""" :: """
|
|
||||||
trait Main5 { def main(args: Array[String]) {} }; trait Main5b extends Main5; trait Main5c extends Main2; abstract class Main5d { def main(args: Array[String]) {} };
|
|
||||||
trait Main5e[T] { def main(args: Array[T]) {} }
|
|
||||||
trait Main5f[T <: String] { def main(args: Array[T]) {} }
|
|
||||||
""" :: """
|
|
||||||
object Main6a { var main = () }
|
|
||||||
object Main6b { var main = (args: Array[String]) => () }
|
|
||||||
""" :: """
|
|
||||||
object Main7 { object Main7b extends Main2 }
|
|
||||||
""" :: """
|
|
||||||
object Main8 extends Main2 { object Main7b extends Main2 }
|
|
||||||
""" :: """
|
|
||||||
object Main9 {
|
|
||||||
def main() {}
|
|
||||||
def main(i: Int) {}
|
|
||||||
def main(args: Array[String]) {}
|
|
||||||
}
|
|
||||||
""" :: """
|
|
||||||
object MainA {
|
|
||||||
def main() {}
|
|
||||||
def main(i: Int) {}
|
|
||||||
def main(args: Array[String], other: String) {}
|
|
||||||
def main(i: Array[Int]) {}
|
|
||||||
}
|
|
||||||
object MainA2 {
|
|
||||||
def main[T](args: Array[T]) {}
|
|
||||||
}
|
|
||||||
""" :: """
|
|
||||||
object MainB extends Main2 {
|
|
||||||
def main() {}
|
|
||||||
def main(i: Int) {}
|
|
||||||
}
|
|
||||||
""" :: """
|
|
||||||
object MainC1 {
|
|
||||||
def main(args: Array[String]) = 3
|
|
||||||
}
|
|
||||||
object MainC2 {
|
|
||||||
def main1(args: Array[String]) {}
|
|
||||||
}
|
|
||||||
""" :: """
|
|
||||||
object MainD1 {
|
|
||||||
val main = ()
|
|
||||||
}
|
|
||||||
object MainD2 {
|
|
||||||
val main = (args: Array[String]) => ()
|
|
||||||
}
|
|
||||||
""" :: """
|
|
||||||
object MainE1 {
|
|
||||||
type T = String
|
|
||||||
def main(args: Array[T]) {}
|
|
||||||
}
|
|
||||||
object MainE2 {
|
|
||||||
type AT = Array[String]
|
|
||||||
def main(args: AT) {}
|
|
||||||
}
|
|
||||||
object MainE3 {
|
|
||||||
type U = Unit
|
|
||||||
type T = String
|
|
||||||
def main(args: Array[T]): U = ()
|
|
||||||
}
|
|
||||||
object MainE4 {
|
|
||||||
def main[T](args: Array[String]) {}
|
|
||||||
}
|
|
||||||
object MainE5 {
|
|
||||||
type A[T] = Array[String]
|
|
||||||
def main[T](args: A[T]) {}
|
|
||||||
}
|
|
||||||
object MainE6 extends Main5e[String]
|
|
||||||
object MainE7 extends Main5e[Int]
|
|
||||||
object MainE8 extends Main5f[String]
|
|
||||||
""" :: """
|
|
||||||
object MainF1 extends Application { var x = 3; x = 5 }
|
|
||||||
object MainF2 { def main(args: Array[java.lang.String]) {} }
|
|
||||||
trait MainF3 { def main(args: Array[String]) {} }
|
|
||||||
object MainF4 extends MainF3 { }
|
|
||||||
""" ::
|
|
||||||
Nil
|
|
||||||
val sources = for((source, index) <- sourceContent.zipWithIndex) yield new File("Main" + (index+1) + ".scala") -> source
|
|
||||||
|
|
||||||
"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.full(scalaVersion, files) { (callback, file, scalaInstance, log) =>
|
|
||||||
val expected = Set( main -> "Main", main4 -> "Main4", main8 -> "Main8", main9 -> "Main9", mainB -> "MainB",
|
|
||||||
mainE -> "MainE1", mainE -> "MainE2", mainE -> "MainE3", mainE -> "MainE4", mainE -> "MainE5", mainE -> "MainE6", mainE -> "MainE8",
|
|
||||||
mainF -> "MainF1", mainF -> "MainF2", mainF -> "MainF4")
|
|
||||||
// the source signature is valid for the following, but the binary signature is not, so they can't actually be run.
|
|
||||||
// these are then known discrepancies between detected and actual entry points
|
|
||||||
val erased = Set( mainE -> "MainE6", mainE -> "MainE8" )
|
|
||||||
val actual = applications(callback).toSet
|
|
||||||
(actual -- expected) must beEmpty
|
|
||||||
(expected -- actual) must beEmpty
|
|
||||||
val loader = new URLClassLoader(Array(file.toURI.toURL), scalaInstance.loader)
|
|
||||||
for( (_, className) <- expected filterNot erased) testRun(loader, className)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
def applications(callback: xsbti.TestCallback): Seq[(File, String)] =
|
|
||||||
for( (file, api) <- CallbackTest.apis(callback);
|
|
||||||
x = println("\n" + file + ":\n" + (api.definitions.flatMap { case c: xsbti.api.ClassLike => c.structure.inherited.filter(_.name == "main"); case _ => Nil }).map(xsbt.api.DefaultShowAPI.apply).mkString("\n"));
|
|
||||||
application <- applications(api))
|
|
||||||
yield (file, application)
|
|
||||||
def applications(src: xsbti.api.SourceAPI): Seq[String] =
|
|
||||||
Discovery.applications(src.definitions) collect { case (definition, Discovered(_, _, true, _)) => definition.name }
|
|
||||||
|
|
||||||
private def testRun(loader: ClassLoader, className: String)
|
|
||||||
{
|
|
||||||
val obj = Class.forName(className, true, loader)
|
|
||||||
obj.getMethod("main", classOf[Array[String]]).invoke(null, new Array[String](0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,68 +0,0 @@
|
||||||
package sbt
|
|
||||||
package compiler
|
|
||||||
|
|
||||||
import java.io.File
|
|
||||||
import org.specs.Specification
|
|
||||||
|
|
||||||
object CheckBasicAPI extends Specification
|
|
||||||
{
|
|
||||||
val basicName = new File("Basic.scala")
|
|
||||||
val basicSource =
|
|
||||||
"""
|
|
||||||
package org.example {
|
|
||||||
trait Parent[A] { def x: A }
|
|
||||||
abstract class Child extends Parent[String]
|
|
||||||
class S {
|
|
||||||
def x = new { def y = new S { def z = new Child { def x = "asdf" } } }
|
|
||||||
final val xconst = 3
|
|
||||||
private[this] def zz: Seq[_] = Nil
|
|
||||||
type L[M[_], P >: Int <: Int] = M[P]
|
|
||||||
type Q = L[Option, Int]
|
|
||||||
}
|
|
||||||
object Basic
|
|
||||||
trait Out {
|
|
||||||
trait In
|
|
||||||
def t: In
|
|
||||||
}
|
|
||||||
}
|
|
||||||
package org.example3 {
|
|
||||||
trait A extends Iterator[Int]
|
|
||||||
}
|
|
||||||
package org.example2 {
|
|
||||||
trait ZZ[S] {
|
|
||||||
val p: S
|
|
||||||
val q: ZZZ[S] { val what: S }
|
|
||||||
class A extends ZZZ[S] {
|
|
||||||
val p = error("")
|
|
||||||
val q = error("")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
trait ZZZ[T] extends ZZ[List[T]]
|
|
||||||
trait ZZZZ extends ZZZ[Int]
|
|
||||||
trait Z extends ZZZZ
|
|
||||||
trait P[S] {
|
|
||||||
trait Q
|
|
||||||
def x(s: S): S
|
|
||||||
def q(v: Q): Q
|
|
||||||
val u: Q
|
|
||||||
val p: S
|
|
||||||
}
|
|
||||||
trait Out { self: P[String] =>
|
|
||||||
trait In
|
|
||||||
def z = p
|
|
||||||
def t(i: In): In
|
|
||||||
def y(q: Q): Q
|
|
||||||
}
|
|
||||||
}
|
|
||||||
"""
|
|
||||||
|
|
||||||
"Compiling should succeed" in {
|
|
||||||
WithFiles(basicName -> basicSource){ files =>
|
|
||||||
for(scalaVersion <- TestCompile.allVersions)
|
|
||||||
{
|
|
||||||
TestCompile(scalaVersion, files){ loader => Class.forName("org.example.Basic", false, loader) }
|
|
||||||
true must beTrue // don't know how to just check that previous line completes without exception
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,43 +0,0 @@
|
||||||
package sbt
|
|
||||||
package compiler
|
|
||||||
|
|
||||||
import java.io.File
|
|
||||||
import org.specs.Specification
|
|
||||||
|
|
||||||
object CheckBasic extends Specification
|
|
||||||
{
|
|
||||||
val basicName = new File("Basic.scala")
|
|
||||||
val basicSource = "package org.example { /** A comment */ object Basic }"
|
|
||||||
|
|
||||||
"Compiling basic file should succeed" in {
|
|
||||||
WithFiles(basicName -> basicSource){ files =>
|
|
||||||
for(scalaVersion <- TestCompile.allVersions)
|
|
||||||
{
|
|
||||||
TestCompile(scalaVersion, files){ loader => Class.forName("org.example.Basic", false, loader) }
|
|
||||||
true must beTrue // don't know how to just check that previous line completes without exception
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
"Scaladoc on basic file should succeed" in {
|
|
||||||
WithFiles(basicName -> basicSource){ files =>
|
|
||||||
for(scalaVersion <- TestCompile.allVersions)
|
|
||||||
{
|
|
||||||
IO.withTemporaryDirectory { outputDirectory =>
|
|
||||||
WithCompiler(scalaVersion) { (compiler, log) =>
|
|
||||||
compiler.doc(files.toSeq, Nil, outputDirectory, Nil, 5, log)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
true must beTrue // don't know how to just check that previous line completes without exception
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
"Analyzer plugin should send source begin and end" in {
|
|
||||||
WithFiles(basicName -> basicSource) { files =>
|
|
||||||
for(scalaVersion <- TestCompile.allVersions)
|
|
||||||
CallbackTest.simple(scalaVersion, files) { callback =>
|
|
||||||
(callback.beganSources) must haveTheSameElementsAs(files)
|
|
||||||
(callback.endedSources) must haveTheSameElementsAs(files)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,97 +0,0 @@
|
||||||
package sbt
|
|
||||||
package compiler
|
|
||||||
|
|
||||||
import java.io.File
|
|
||||||
import IO.withTemporaryDirectory
|
|
||||||
import org.specs._
|
|
||||||
|
|
||||||
object CompileTest extends Specification
|
|
||||||
{
|
|
||||||
"Analysis compiler" should {
|
|
||||||
"compile basic sources" in {
|
|
||||||
WithCompiler( "2.9.1" )(testCompileAnalysis)
|
|
||||||
WithCompiler( "2.9.0-1" )(testCompileAnalysis)
|
|
||||||
WithCompiler( "2.8.0" )(testCompileAnalysis)
|
|
||||||
WithCompiler( "2.8.1" )(testCompileAnalysis)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
"Raw compiler" should {
|
|
||||||
"Properly handle classpaths" in {
|
|
||||||
testClasspath("2.9.1")
|
|
||||||
testClasspath("2.9.0-1")
|
|
||||||
testClasspath("2.8.1")
|
|
||||||
testClasspath("2.8.0")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private def testCompileAnalysis(compiler: AnalyzingCompiler, log: Logger)
|
|
||||||
{
|
|
||||||
WithFiles( new File("Test.scala") -> "object Test" ) { sources =>
|
|
||||||
withTemporaryDirectory { temp =>
|
|
||||||
val callback = new xsbti.TestCallback
|
|
||||||
compiler(sources, noChanges, Nil, temp, Nil, callback, 10, CompilerCache.fresh, log)
|
|
||||||
(callback.beganSources) must haveTheSameElementsAs(sources)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
val noChanges = new xsbti.compile.DependencyChanges {
|
|
||||||
def isEmpty = true
|
|
||||||
def modifiedBinaries = Array()
|
|
||||||
def modifiedClasses = Array()
|
|
||||||
}
|
|
||||||
|
|
||||||
val UsingCompiler = "object Test { classOf[scala.tools.nsc.Global] }"
|
|
||||||
|
|
||||||
private def shouldFail(act: => Unit) =
|
|
||||||
{
|
|
||||||
val success = try { act; true } catch { case t if expectedException(t) => false }
|
|
||||||
if(success) error("Expected exception not thrown")
|
|
||||||
}
|
|
||||||
private def expectedException(t: Throwable) =
|
|
||||||
t match
|
|
||||||
{
|
|
||||||
case e: Exception => true
|
|
||||||
case t if isMissingRequirementError(t) => true
|
|
||||||
case _ => false
|
|
||||||
}
|
|
||||||
private def shouldSucceed(act: => Unit) =
|
|
||||||
try { act } catch { case c: xsbti.CompileFailed => error(c.toString) }
|
|
||||||
|
|
||||||
private def isMissingRequirementError(t: Throwable) = t.getClass.getName == "scala.tools.nsc.MissingRequirementError"
|
|
||||||
private def testClasspath(scalaVersion: String) =
|
|
||||||
WithCompiler.launcher { (launch, log) =>
|
|
||||||
def compiler(bootLibrary: Boolean, compilerOnClasspath: Boolean): RawCompiler =
|
|
||||||
new RawCompiler(ScalaInstance(scalaVersion, launch), new ClasspathOptions(bootLibrary, compilerOnClasspath, true, true, bootLibrary), log)
|
|
||||||
|
|
||||||
val callback = new xsbti.TestCallback
|
|
||||||
|
|
||||||
val standard = compiler(true, true)
|
|
||||||
val noCompiler = compiler(true, false)
|
|
||||||
val fullExplicit = compiler(false, false)
|
|
||||||
|
|
||||||
val fullBoot = "-bootclasspath" :: fullExplicit.compilerArguments.createBootClasspath(true) :: Nil
|
|
||||||
val withCompiler = noCompiler.scalaInstance.compilerJar :: Nil
|
|
||||||
val withLibrary = noCompiler.scalaInstance.libraryJar :: Nil
|
|
||||||
val withLibraryCompiler = withLibrary ++ withCompiler
|
|
||||||
|
|
||||||
WithFiles( new File("Test.scala") -> "object Test", new File("Test2.scala") -> UsingCompiler ) { case Seq(plain, useCompiler) =>
|
|
||||||
val plainSrcs = Seq[File](plain)
|
|
||||||
val compSrcs = Seq[File](useCompiler)
|
|
||||||
withTemporaryDirectory { out =>
|
|
||||||
shouldSucceed( standard(plainSrcs, Nil, out, Nil) )
|
|
||||||
shouldSucceed( standard(compSrcs, Nil, out, Nil) )
|
|
||||||
|
|
||||||
shouldSucceed( noCompiler(plainSrcs, Nil, out, Nil) )
|
|
||||||
shouldFail( noCompiler(compSrcs, Nil, out, Nil) )
|
|
||||||
shouldSucceed( noCompiler(compSrcs, withCompiler, out, Nil) )
|
|
||||||
|
|
||||||
shouldFail( fullExplicit(plainSrcs, Nil, out, Nil) )
|
|
||||||
shouldFail( fullExplicit(compSrcs, Nil, out, Nil) )
|
|
||||||
shouldSucceed( fullExplicit(plainSrcs, withLibrary, out, fullBoot) )
|
|
||||||
shouldSucceed( fullExplicit(compSrcs, withLibraryCompiler, out, fullBoot) )
|
|
||||||
true must beTrue
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,61 +0,0 @@
|
||||||
package xsbt.api
|
|
||||||
|
|
||||||
import sbt.WithFiles
|
|
||||||
import sbt.compiler.{CallbackTest,TestCompile}
|
|
||||||
import java.io.File
|
|
||||||
import org.specs.Specification
|
|
||||||
|
|
||||||
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; @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 @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 { @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 { @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(a, b, c, sup1File, sup2File, sup3File, sup4File, midFile, sub1File, sub2File, sub3File, sub4File, sub5File, sub6File, sub7File, sub8File, sub9File, subAFile, subBFile) =>
|
|
||||||
for(scalaVersion <- TestCompile.allVersions)
|
|
||||||
CallbackTest.simple(scalaVersion, files) { callback =>
|
|
||||||
val expected =
|
|
||||||
(sup3File, "Super3", Set("B"), false) ::
|
|
||||||
(sub3File, "Sub3", Set("B", "c.A"), false) ::
|
|
||||||
(sub7File, "Sub7", Set("d.C"), false) ::
|
|
||||||
(sub8File, "Sub8", Set("c.A"), false) ::
|
|
||||||
(sub9File, "Sub9", Set("B"), true) ::
|
|
||||||
(subAFile, "SubA", Set("c.A"), true) ::
|
|
||||||
(subBFile, "SubB", Set("c.A"), true) ::
|
|
||||||
(subBFile, "SubB", Set("d.C"), false) ::
|
|
||||||
Nil
|
|
||||||
val actual = subclasses(callback).toSet
|
|
||||||
val actualOnly = (actual -- expected)
|
|
||||||
val expectedOnly = (expected.toSet -- actual)
|
|
||||||
expectedOnly must beEmpty
|
|
||||||
actualOnly must beEmpty
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
def subclasses(callback: xsbti.TestCallback): Seq[(File, String, Set[String], Boolean)] =
|
|
||||||
for( (file, src) <- CallbackTest.apis(callback); (definition, discovered) <- Discovery(Set.empty, annotationNames)(src.definitions) if !discovered.isEmpty ) yield
|
|
||||||
(file, definition.name, discovered.annotations, discovered.isModule)
|
|
||||||
|
|
||||||
def annotationNames = Set("c.A", "B", "d.C")
|
|
||||||
}
|
|
||||||
|
|
@ -1,43 +0,0 @@
|
||||||
package xsbt.api
|
|
||||||
|
|
||||||
import sbt.WithFiles
|
|
||||||
import sbt.compiler.{CallbackTest,TestCompile}
|
|
||||||
import java.io.File
|
|
||||||
import org.specs.Specification
|
|
||||||
|
|
||||||
object DetectSubclasses extends Specification
|
|
||||||
{
|
|
||||||
val sources =
|
|
||||||
("a/Super.scala" -> "package a; trait Super") ::
|
|
||||||
("a/Super2.scala" -> "class Super2") ::
|
|
||||||
("b/Middle.scala" -> "package y.w; trait Mid extends a.Super") ::
|
|
||||||
("b/Sub1.scala" -> "package a; class Sub1 extends y.w.Mid") ::
|
|
||||||
("b/Sub2.scala" -> "final class Sub2 extends a.Super") ::
|
|
||||||
("Sub3.scala" -> "private class F extends a.Super; package c { object Sub3 extends Super2 }") ::
|
|
||||||
Nil
|
|
||||||
|
|
||||||
"Analysis plugin should detect subclasses" in {
|
|
||||||
WithFiles(sources.map{case (file, content) => (new File(file), content)} : _*)
|
|
||||||
{
|
|
||||||
case files @ Seq(supFile, sup2File, midFile, sub1File, sub2File, sub3File) =>
|
|
||||||
for(scalaVersion <- TestCompile.allVersions)
|
|
||||||
CallbackTest.simple(scalaVersion, files) { callback =>
|
|
||||||
val expected =
|
|
||||||
(sub1File, "a.Sub1", Set("a.Super"), false) ::
|
|
||||||
(sub2File, "Sub2", Set("a.Super"), false) ::
|
|
||||||
(sup2File, "Super2", Set("Super2"), false) ::
|
|
||||||
(sub3File, "c.Sub3", Set("Super2"), true) ::
|
|
||||||
Nil
|
|
||||||
val actual = subclasses(callback).toSet
|
|
||||||
val actualOnly = actual -- expected
|
|
||||||
val expectedOnly = expected.toSet -- actual
|
|
||||||
actualOnly must beEmpty
|
|
||||||
expectedOnly must beEmpty
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
def subclasses(callback: xsbti.TestCallback): Seq[(File, String, Set[String], Boolean)] =
|
|
||||||
for( (file, src) <- CallbackTest.apis(callback); (definition, discovered) <- Discovery(subclassNames, Set.empty)(src.definitions) if !discovered.isEmpty ) yield
|
|
||||||
(file, definition.name, discovered.baseClasses, discovered.isModule)
|
|
||||||
def subclassNames = Set( "a.Super", "Super2", "x.Super3", "Super4")
|
|
||||||
}
|
|
||||||
|
|
@ -1,38 +0,0 @@
|
||||||
package sbt
|
|
||||||
package compiler
|
|
||||||
|
|
||||||
import java.io.File
|
|
||||||
import java.net.URLClassLoader
|
|
||||||
import xsbti.TestCallback
|
|
||||||
import IO.withTemporaryDirectory
|
|
||||||
|
|
||||||
object TestCompile
|
|
||||||
{
|
|
||||||
def allVersions = List("2.8.1", "2.9.0-1", "2.8.0", "2.9.1")
|
|
||||||
/** 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: Seq[File], outputDirectory: File, options: Seq[String])
|
|
||||||
(f: (TestCallback, xsbti.compile.ScalaInstance, Logger) => T): T =
|
|
||||||
{
|
|
||||||
val testCallback = new TestCallback
|
|
||||||
WithCompiler(scalaVersion) { (compiler, log) =>
|
|
||||||
compiler(sources, CompileTest.noChanges, Nil, outputDirectory, options, testCallback, 5, CompilerCache.fresh, 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.full(scalaVersion, sources){ case (_, outputDir, _, _) => f(new URLClassLoader(Array(outputDir.toURI.toURL))) }
|
|
||||||
}
|
|
||||||
object CallbackTest
|
|
||||||
{
|
|
||||||
def simple[T](scalaVersion: String, sources: Seq[File])(f: TestCallback => T): T =
|
|
||||||
full(scalaVersion, sources){ case (callback, _, _, _) => f(callback) }
|
|
||||||
def full[T](scalaVersion: String, sources: Seq[File])(f: (TestCallback, File, xsbti.compile.ScalaInstance, Logger) => T): T =
|
|
||||||
withTemporaryDirectory { outputDir =>
|
|
||||||
TestCompile(scalaVersion, sources, outputDir, Nil) { case (callback, instance, log) => f(callback, outputDir, instance, log) }
|
|
||||||
}
|
|
||||||
def apis(callback: xsbti.TestCallback) =
|
|
||||||
callback.apis.toSeq map { case (src, api) => (src, xsbt.api.APIUtil.minimize(api)) }
|
|
||||||
}
|
|
||||||
|
|
@ -1,39 +0,0 @@
|
||||||
package sbt
|
|
||||||
package compiler
|
|
||||||
|
|
||||||
import xsbt.boot
|
|
||||||
import java.io.File
|
|
||||||
import IO.withTemporaryDirectory
|
|
||||||
|
|
||||||
object WithCompiler
|
|
||||||
{
|
|
||||||
def apply[T](scalaVersion: String)(f: (AnalyzingCompiler, Logger) => T): T =
|
|
||||||
{
|
|
||||||
launcher { (launch, log) =>
|
|
||||||
withTemporaryDirectory { componentDirectory =>
|
|
||||||
val manager = new ComponentManager(xsbt.boot.Locks, new boot.ComponentProvider(componentDirectory, true), None, log)
|
|
||||||
val compiler = new AnalyzingCompiler(ScalaInstance(scalaVersion, launch), manager, log)
|
|
||||||
compiler.newComponentCompiler(log).clearCache(ComponentCompiler.compilerInterfaceID)
|
|
||||||
define(manager, ComponentCompiler.compilerInterfaceSrcID, getResource("CompilerInterface.scala"), getClassResource(classOf[jline.Completor]))
|
|
||||||
define(manager, ComponentCompiler.xsbtiID, getClassResource(classOf[xsbti.AnalysisCallback]))
|
|
||||||
f(compiler, log)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
def launcher[T](f: (xsbti.Launcher, Logger) => T): T =
|
|
||||||
TestLogger { log =>
|
|
||||||
boot.LaunchTest.withLauncher { launch => f(launch, log) }
|
|
||||||
}
|
|
||||||
|
|
||||||
def getClassResource(resource: Class[_]): File = IO.classLocationFile(resource)
|
|
||||||
def getResource(resource: String): File =
|
|
||||||
{
|
|
||||||
val src = getClass.getClassLoader.getResource(resource)
|
|
||||||
if(src ne null) IO.asFile(src) else error("Resource not found: " + resource)
|
|
||||||
}
|
|
||||||
def define(manager: ComponentManager, id: String, files: File*)
|
|
||||||
{
|
|
||||||
manager.clearCache(id)
|
|
||||||
manager.define(id, files)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue