Merge pull request #78 from cvogt/chris

Chris

17 files changed, 172 insertions, 131 deletions

diff --git a/cbt b/cbt
index aa92023..6b2242c 100755
--- a/cbt
+++ b/cbt
@@ -192,7 +192,7 @@ stage1 () {
 	fi
 
 	log "run CBT and loop if desired. This allows recompiling CBT itself as part of compile looping." $*
-	if [ "$1" = "admin" ]; then
+	if [ "$1" = "admin" ] || [ "$2" = "admin" ]; then
 		mainClass=cbt.AdminStage1
 	else
 		mainClass=cbt.Stage1
diff --git a/stage1/ClassLoaderCache.scala b/stage1/ClassLoaderCache.scala
new file mode 100644
index 0000000..18a0d0e
--- /dev/null
+++ b/stage1/ClassLoaderCache.scala
@@ -0,0 +1,25 @@
+package cbt
+
+import java.net._
+
+private[cbt] object ClassLoaderCache{
+  private val cache = NailgunLauncher.classLoaderCache
+  def get( classpath: ClassPath )(implicit logger: Logger): ClassLoader
+    = cache.synchronized{
+    val lib = new Stage1Lib(logger)
+    val key = classpath.strings.sorted.mkString(":")
+    if( cache.containsKey(key) ){
+      logger.resolver("CACHE HIT: "++key)
+      cache.get(key)
+    } else {
+      logger.resolver("CACHE MISS: "++key)
+      val cl = new cbt.URLClassLoader( classpath, ClassLoader.getSystemClassLoader )
+      cache.put( key, cl )
+      cl
+    }
+  }
+  def remove( classpath: ClassPath ) = {
+    val key = classpath.strings.sorted.mkString(":")
+    cache.remove( key )
+  }
+}
diff --git a/stage1/MultiClassLoader.scala b/stage1/MultiClassLoader.scala
new file mode 100644
index 0000000..de9bd32
--- /dev/null
+++ b/stage1/MultiClassLoader.scala
@@ -0,0 +1,24 @@
+/*
+package cbt
+import java.net._
+import scala.util.Try
+
+import scala.collection.immutable.Seq
+
+
+class MultiClassLoader(parents: Seq[ClassLoader]) extends ClassLoader {
+  override def loadClass(name: String) = {
+    //System.err.println("LOADING CLASS "++name);
+    val c = parents.toStream.map{
+      parent =>
+      Try{
+        parent.loadClass(name)
+      }.map(Option[Class[_]](_)).recover{
+        case _:ClassNotFoundException => None
+      }.get
+    }.find(_.isDefined).flatten
+    c.getOrElse( ClassLoader.getSystemClassLoader.loadClass(name) )
+  }
+  override def toString = "MultiClassLoader(" ++ parents.mkString(",") ++ ")"
+}
+*/
diff --git a/stage1/Stage1.scala b/stage1/Stage1.scala
index 1aa3f09..7702678 100644
--- a/stage1/Stage1.scala
+++ b/stage1/Stage1.scala
@@ -67,14 +67,16 @@ abstract class Stage1Base{
 
     logger.stage1("before conditionally running zinc to recompile CBT")
     if( src.exists(newerThan(_, changeIndicator)) ) {
-      val stage1Classpath = CbtDependency(logger).dependencyClasspath
+      val stage1Classpath = CbtDependency()(logger).dependencyClasspath
       logger.stage1("cbt.lib has changed. Recompiling with cp: " ++ stage1Classpath.string)
       zinc( true, src, stage2Target, stage1Classpath )( zincVersion = "0.3.9", scalaVersion = constants.scalaVersion )
     }
     logger.stage1(s"[$now] calling CbtDependency.classLoader")
 
     logger.stage1(s"[$now] Run Stage2")
-    val ExitCode(exitCode) = runMain( mainClass, cwd +: args.drop(1).toVector, CbtDependency(logger).classLoader )
+    val ExitCode(exitCode) = /*trapExitCode*/{ // this 
+      runMain( mainClass, cwd +: args.drop(1).toVector, CbtDependency()(logger).classLoader )
+    }
     logger.stage1(s"[$now] Stage1 end")
     System.exit(exitCode)
   }
diff --git a/stage1/Stage1Lib.scala b/stage1/Stage1Lib.scala
index 1ad3030..67ae049 100644
--- a/stage1/Stage1Lib.scala
+++ b/stage1/Stage1Lib.scala
@@ -190,6 +190,11 @@ class Stage1Lib( val logger: Logger ) extends BaseLib{
   }
 
   def trapExitCode( code: => Unit ): ExitCode = {
+    /*
+    Doesn't seem to work reliably. Seems like the Security manager is not always
+    reset properly. Maybe some non-thread-safety issue or some Nailgun interaction.
+
+
     val old: Option[SecurityManager] = Option(System.getSecurityManager())
     try{
       val securityManager = new SecurityManager{
@@ -217,6 +222,9 @@ class Stage1Lib( val logger: Logger ) extends BaseLib{
     } finally {
       System.setSecurityManager(old.getOrElse(null))
     }
+    */
+    code
+    ExitCode.Success
   }
 }
 
diff --git a/stage1/URLClassLoader.scala b/stage1/URLClassLoader.scala
new file mode 100644
index 0000000..870f186
--- /dev/null
+++ b/stage1/URLClassLoader.scala
@@ -0,0 +1,22 @@
+package cbt
+
+import java.net._
+
+case class URLClassLoader(classPath: ClassPath, parent: ClassLoader)
+  extends java.net.URLClassLoader(
+    classPath.strings.map(
+      path => new URL("file:"++path)
+    ).toArray,
+    parent
+  ){
+  override def toString = (
+    scala.Console.BLUE ++ "cbt.URLClassLoader" ++ scala.Console.RESET
+      ++ "(\n  " ++ getURLs.map(_.toString).sorted.mkString(",\n  ")
+      ++ (
+        if(getParent() != ClassLoader.getSystemClassLoader())
+          ",\n" ++ getParent().toString.split("\n").map("  "++_).mkString("\n")
+        else ""
+      )
+      ++ "\n)"
+  )
+}
diff --git a/stage1/classloader.scala b/stage1/classloader.scala
deleted file mode 100644
index 50e33a2..0000000
--- a/stage1/classloader.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-package cbt
-import java.io._
-import java.net._
-import java.nio.file._
-import scala.util.Try
-
-import scala.collection.immutable.Seq
-
-object ClassLoaderCache{
-  private val cache = NailgunLauncher.classLoaderCache
-  def get( classpath: ClassPath )(implicit logger: Logger): ClassLoader
-    = cache.synchronized{
-    val lib = new Stage1Lib(logger)
-    val key = classpath.strings.sorted.mkString(":")
-    if( cache.containsKey(key) ){
-      logger.resolver("CACHE HIT: "++key)
-      cache.get(key)
-    } else {
-      logger.resolver("CACHE MISS: "++key)
-      val cl = new cbt.URLClassLoader( classpath, ClassLoader.getSystemClassLoader )
-      cache.put( key, cl )
-      cl
-    }
-  }
-  def remove( classpath: ClassPath ) = {
-    val key = classpath.strings.sorted.mkString(":")
-    cache.remove( key )
-  }
-}
-/*
-class MultiClassLoader(parents: Seq[ClassLoader]) extends ClassLoader {
-  override def loadClass(name: String) = {
-    //System.err.println("LOADING CLASS "++name);
-    val c = parents.toStream.map{
-      parent =>
-      Try{
-        parent.loadClass(name)
-      }.map(Option[Class[_]](_)).recover{
-        case _:ClassNotFoundException => None
-      }.get
-    }.find(_.isDefined).flatten
-    c.getOrElse( ClassLoader.getSystemClassLoader.loadClass(name) )
-  }
-  override def toString = "MultiClassLoader(" ++ parents.mkString(",") ++ ")"
-}
-*/
-case class URLClassLoader(classPath: ClassPath, parent: ClassLoader)
-  extends java.net.URLClassLoader(
-    classPath.strings.map(
-      path => new URL("file:"++path)
-    ).toArray,
-    parent
-  ){
-  override def toString = (
-    scala.Console.BLUE ++ "cbt.URLClassLoader" ++ scala.Console.RESET
-      ++ "(\n  " ++ getURLs.map(_.toString).sorted.mkString(",\n  ")
-      ++ (
-        if(getParent() != ClassLoader.getSystemClassLoader())
-          ",\n" ++ getParent().toString.split("\n").map("  "++_).mkString("\n")
-        else ""
-      )
-      ++ "\n)"
-  )
-}
diff --git a/stage1/resolver.scala b/stage1/resolver.scala
index fae5e9d..30f03e2 100644
--- a/stage1/resolver.scala
+++ b/stage1/resolver.scala
@@ -32,12 +32,13 @@ abstract class Dependency{
   def exportedJars: Seq[File]
   def jars: Seq[File] = exportedJars ++ dependencyJars
 
+  def canBeCached = false
   def cacheDependencyClassLoader = true
 
   private object cacheClassLoaderBasicBuild extends Cache[URLClassLoader]
   def classLoader: URLClassLoader = cacheClassLoaderBasicBuild{
     val transitiveClassPath = transitiveDependencies.map{
-      case d: MavenDependency => Left(d)
+      case d if d.canBeCached => Left(d)
       case d => Right(d)
     }
     val buildClassPath = ClassPath.flatten(
@@ -95,35 +96,39 @@ abstract class Dependency{
 }
 
 // TODO: all this hard codes the scala version, needs more flexibility
-class ScalaCompiler(logger: Logger) extends MavenDependency("org.scala-lang","scala-compiler",constants.scalaVersion)(logger)
-class ScalaLibrary(logger: Logger) extends MavenDependency("org.scala-lang","scala-library",constants.scalaVersion)(logger)
-class ScalaReflect(logger: Logger) extends MavenDependency("org.scala-lang","scala-reflect",constants.scalaVersion)(logger)
+class ScalaCompilerDependency(version: String)(implicit logger: Logger) extends MavenDependency("org.scala-lang","scala-compiler",version)
+class ScalaLibraryDependency (version: String)(implicit logger: Logger) extends MavenDependency("org.scala-lang","scala-library",version)
+class ScalaReflectDependency (version: String)(implicit logger: Logger) extends MavenDependency("org.scala-lang","scala-reflect",version)
 
-case class ScalaDependencies(logger: Logger) extends Dependency{
+case class ScalaDependencies(version: String)(implicit val logger: Logger) extends Dependency{ sd =>
+  final val updated = false
+  override def canBeCached = true
   def exportedClasspath = ClassPath(Seq())
   def exportedJars = Seq[File]()  
-  def dependencies = Seq( new ScalaCompiler(logger), new ScalaLibrary(logger), new ScalaReflect(logger) )
-  final val updated = false
+  def dependencies = Seq(
+    new ScalaCompilerDependency(version)(logger),
+    new ScalaLibraryDependency(version)(logger),
+    new ScalaReflectDependency(version)(logger)
+  )
 }
 
-/*
-case class BinaryDependency( path: File, dependencies: Seq[Dependency] ) extends Dependency{
+case class BinaryDependency( path: File, dependencies: Seq[Dependency] )(implicit val logger: Logger) extends Dependency{
+  def updated = false
   def exportedClasspath = ClassPath(Seq(path))
-  def exportedJars = Seq[File]()
+  def exportedJars = Seq[File](path)
 }
-*/
 
-case class Stage1Dependency(logger: Logger) extends Dependency{
+case class Stage1Dependency()(implicit val logger: Logger) extends Dependency{
   def exportedClasspath = ClassPath( Seq(nailgunTarget, stage1Target) )
   def exportedJars = Seq[File]()  
-  def dependencies = ScalaDependencies(logger: Logger).dependencies
+  def dependencies = ScalaDependencies(constants.scalaVersion).dependencies
   def updated = false // FIXME: think this through, might allow simplifications and/or optimizations
 }
-case class CbtDependency(logger: Logger) extends Dependency{
+case class CbtDependency()(implicit val logger: Logger) extends Dependency{
   def exportedClasspath = ClassPath( Seq( stage2Target ) )
   def exportedJars = Seq[File]()  
   override def dependencies = Seq(
-    Stage1Dependency(logger),
+    Stage1Dependency()(logger),
     MavenDependency("net.incongru.watchservice","barbary-watchservice","1.0")(logger),
     MavenDependency("com.lihaoyi","ammonite-repl_2.11.7","0.5.5")(logger),
     MavenDependency("org.scala-lang.modules","scala-xml_2.11","1.0.5")(logger)
@@ -136,10 +141,11 @@ final case class Classifier(name: String) extends ClassifierBase
 case object javadoc extends ClassifierBase
 case object sources extends ClassifierBase
 
-case class MavenDependency( groupId: String, artifactId: String, version: String, sources: Boolean = false )(val logger: Logger)
+case class MavenDependency( groupId: String, artifactId: String, version: String, sources: Boolean = false )(implicit val logger: Logger)
   extends ArtifactInfo{
 
   def updated = false
+  override def canBeCached = true
 
   private val groupPath = groupId.split("\\.").mkString("/")
   def basePath = s"/$groupPath/$artifactId/$version/$artifactId-$version"++(if(sources) "-sources" else "")
diff --git a/stage2/AdminStage2.scala b/stage2/AdminStage2.scala
index 4120b1c..59f8f7d 100644
--- a/stage2/AdminStage2.scala
+++ b/stage2/AdminStage2.scala
@@ -1,11 +1,12 @@
 package cbt
 object AdminStage2{
-  def main(args: Array[String]) = {
-    val init = new Init(args.drop(3))
+  def main(_args: Array[String]) = {
+    val args = _args.drop(1).dropWhile(Seq("admin","direct") contains _)
+    val init = new Init(args)
     val lib = new Lib(init.logger)
-    val adminTasks = new AdminTasks(lib, args.drop(3))
+    val adminTasks = new AdminTasks(lib, args)
     new lib.ReflectObject(adminTasks){
       def usage: String = "Available methods: " ++ lib.taskNames(subclassType).mkString("  ")
-    }.callNullary(args.lift(2))
+    }.callNullary(args.lift(0))
   }
 }
diff --git a/stage2/AdminTasks.scala b/stage2/AdminTasks.scala
index 2f7efe1..70b140e 100644
--- a/stage2/AdminTasks.scala
+++ b/stage2/AdminTasks.scala
@@ -1,12 +1,33 @@
 package cbt
+import scala.collection.immutable.Seq
 class AdminTasks(lib: Lib, args: Array[String]){
+  implicit val logger: Logger = lib.logger
   def resolve = {
     ClassPath.flatten(
-      args(0).split(",").toVector.map{
+      args(1).split(",").toVector.map{
         d =>
           val v = d.split(":")
           new MavenDependency(v(0),v(1),v(2))(lib.logger).classpath
       }
     )
   }
+  def amm = ammonite
+  def ammonite = {
+    val version = args.lift(1).getOrElse(constants.scalaVersion)
+    val scalac = new ScalaCompilerDependency( version )
+    val d = MavenDependency(
+      "com.lihaoyi","ammonite-repl_2.11.7",args.lift(1).getOrElse("0.5.6")
+    )
+    // FIXME: this does not work quite yet, throws NoSuchFileException: /ammonite/repl/frontend/ReplBridge$.class
+    lib.runMain(
+      "ammonite.repl.Main", Seq(), d.classLoader
+    )
+  }
+  def scala = {
+    val version = args.lift(1).getOrElse(constants.scalaVersion)
+    val scalac = new ScalaCompilerDependency( version )
+    lib.runMain(
+      "scala.tools.nsc.MainGenericRunner", Seq("-cp", scalac.classpath.string), scalac.classLoader
+    )
+  }
 }
diff --git a/stage2/BasicBuild.scala b/stage2/BasicBuild.scala
index c17bce0..bee58dd 100644
--- a/stage2/BasicBuild.scala
+++ b/stage2/BasicBuild.scala
@@ -15,10 +15,10 @@ import scala.util._
 
 import ammonite.ops.{cwd => _,_}
 
-class BasicBuild(context: Context) extends Build(context)
+class BasicBuild( context: Context ) extends Build( context )
 class Build(val context: Context) extends Dependency with TriggerLoop{
   // library available to builds
-  final val logger = context.logger
+  implicit final val logger: Logger = context.logger
   override final protected val lib: Lib = new Lib(logger)
   
   // ========== general stuff ==========
diff --git a/stage2/BuildBuild.scala b/stage2/BuildBuild.scala
index 9283cdf..5e0f5d3 100644
--- a/stage2/BuildBuild.scala
+++ b/stage2/BuildBuild.scala
@@ -3,7 +3,7 @@ import java.io.File
 import scala.collection.immutable.Seq
 
 class BuildBuild(context: Context) extends Build(context){
-  override def dependencies = Seq( CbtDependency(context.logger) ) ++ super.dependencies
+  override def dependencies = Seq( CbtDependency()(context.logger) ) ++ super.dependencies
   def managedBuildDirectory: File = lib.realpath( projectDirectory.parent )
   val managedBuild = {
     val managedContext = context.copy( cwd = managedBuildDirectory )
diff --git a/stage2/Lib.scala b/stage2/Lib.scala
index 6f83859..e87a19d 100644
--- a/stage2/Lib.scala
+++ b/stage2/Lib.scala
@@ -80,35 +80,29 @@ final class Lib(logger: Logger) extends Stage1Lib(logger) with Scaffold{
   }
 
   def docJar(
+    scalaVersion: String,
     sourceFiles: Seq[File],
-    dependenyClasspath: ClassPath,
+    dependencyClasspath: ClassPath,
     apiTarget: File,
     jarTarget: File,
     artifactId: String,
     version: String,
     compileArgs: Seq[String]
   ): File = {
-    // FIXME: get this dynamically somehow, or is this even needed?
-    val javacp = ClassPath(
-      "/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/jfxrt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/sunjce_provider.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/sunpkcs11.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home/jre/lib/ext/zipfs.jar:/System/Library/Java/Extensions/MRJToolkit.jar".split(":").toVector.map(new File(_))
-    )
-
     mkdir(Path(apiTarget))
     if(sourceFiles.nonEmpty){    
-      System.err.println("creating docs")
+      val args = Seq(
+        // FIXME: can we use compiler dependency here?
+        "-cp", dependencyClasspath.string, // FIXME: does this break for builds that don't have scalac dependencies?
+        "-d",  apiTarget.toString
+      ) ++ compileArgs ++ sourceFiles.map(_.toString)
+      logger.lib("creating docs for source files "+args.mkString(", "))
       trapExitCode{
         redirectOutToErr{        
           runMain(
             "scala.tools.nsc.ScalaDoc",
-            Seq(
-              // FIXME: can we use compiler dependency here?
-              "-cp", /*javacp++":"++*/ScalaDependencies(logger).classpath.string ++ ":" ++ dependenyClasspath.string,
-              "-d",  apiTarget.toString
-            ) ++ compileArgs ++ sourceFiles.map(_.toString),
-            new URLClassLoader(
-              ScalaDependencies(logger).classpath ++ javacp,
-              ClassLoader.getSystemClassLoader
-            )
+            args,
+            ScalaDependencies(scalaVersion)(logger).classLoader
           )
         }
       }
@@ -149,7 +143,7 @@ final class Lib(logger: Logger) extends Stage1Lib(logger) with Scaffold{
   }
 
   class ReflectBuild(val build: Build) extends ReflectObject(build){
-    def usage = {
+    def usage: String = {
       val baseTasks = lib.taskNames(ru.typeOf[Build])
       val thisTasks = lib.taskNames(subclassType) diff baseTasks
       (
@@ -197,7 +191,9 @@ final class Lib(logger: Logger) extends Stage1Lib(logger) with Scaffold{
             System.err.println("")
           }
           System.err.println(usage)
-          System.exit(1)
+          taskName.foreach{ _ =>
+            ExitCode.Failure
+          }
         }
     }
   }
diff --git a/stage2/PackageBuild.scala b/stage2/PackageBuild.scala
index 96c7b6f..4c4e478 100644
--- a/stage2/PackageBuild.scala
+++ b/stage2/PackageBuild.scala
@@ -2,7 +2,7 @@ package cbt
 import java.io.File
 import java.net.URL
 import scala.collection.immutable.Seq
-abstract class PackageBuild(context: Context) extends Build(context) with ArtifactInfo{
+abstract class PackageBuild(context: Context) extends BasicBuild(context) with ArtifactInfo{
   def `package`: Seq[File] = lib.concurrently( enableConcurrency )(
     Seq(() => jar, () => docJar, () => srcJar)
   )( _() )
@@ -14,12 +14,12 @@ abstract class PackageBuild(context: Context) extends Build(context) with Artifa
 
   private object cacheSrcJarBasicBuild extends Cache[File]
   def srcJar: File = cacheSrcJarBasicBuild{
-    lib.srcJar(sources, artifactId, version, scalaTarget)
+    lib.srcJar( sourceFiles, artifactId, version, scalaTarget )
   }
 
   private object cacheDocBasicBuild extends Cache[File]
   def docJar: File = cacheDocBasicBuild{
-    lib.docJar( sources, dependencyClasspath, apiTarget, jarTarget, artifactId, version, scalacOptions )
+    lib.docJar( scalaVersion, sourceFiles, dependencyClasspath, apiTarget, jarTarget, artifactId, version, scalacOptions )
   }
 
   override def jars = jar +: dependencyJars
diff --git a/stage2/Stage2.scala b/stage2/Stage2.scala
index 392e322..4145e55 100644
--- a/stage2/Stage2.scala
+++ b/stage2/Stage2.scala
@@ -31,7 +31,7 @@ object Stage2{
     val first = lib.loadRoot( context )
     val build = first.finalBuild
 
-    val res = lib.trapExitCode{
+    val res =
       if (loop) {
         // TODO: this should allow looping over task specific files, like test files as well
         val triggerFiles = first.triggerLoopFiles.map(lib.realpath)
@@ -54,7 +54,6 @@ object Stage2{
       } else {
         new lib.ReflectBuild(build).callNullary(task)
       }
-    }
 
     init.logger.stage2(s"[$now] Stage2 end")
   }
diff --git a/test/build/build.scala b/test/build/build.scala
index 92a964b..29665a6 100644
--- a/test/build/build.scala
+++ b/test/build/build.scala
@@ -1,5 +1,6 @@
-import scala.collection.immutable.Seq
+import cbt._
 import java.io.File
-class Build(context: cbt.Context) extends cbt.Build(context){
-  override def dependencies = Seq( cbt.CbtDependency(context.logger) ) ++ super.dependencies 
+import scala.collection.immutable.Seq
+class Build(context: cbt.Context) extends BasicBuild(context){
+  override def dependencies = Seq( CbtDependency() ) ++ super.dependencies 
 }
diff --git a/test/test.scala b/test/test.scala
index deaa46c..7c805c9 100644
--- a/test/test.scala
+++ b/test/test.scala
@@ -30,19 +30,18 @@ object Main{
       logger.test(allArgs.toString)
       val pb = new ProcessBuilder( allArgs :_* )
       pb.directory(cbtHome ++ ("/test/" ++ path))
-      val p = pb.inheritIO.start
-      p.waitFor
+      val p = pb.start
       val berr = new BufferedReader(new InputStreamReader(p.getErrorStream));
       val bout = new BufferedReader(new InputStreamReader(p.getInputStream));
-      p.waitFor
       import collection.JavaConversions._
       val err = Stream.continually(berr.readLine()).takeWhile(_ != null).mkString("\n")
       val out = Stream.continually(bout.readLine()).takeWhile(_ != null).mkString("\n")
-      Result(out, err, p.exitValue == 0)
+      p.waitFor
+      Result(p.exitValue == 0, out, err)
     }
-    case class Result(out: String, err: String, exit0: Boolean)
-    def assertSuccess(res: Result)(implicit logger: Logger) = {
-      assert(res.exit0, res.toString)
+    case class Result(exit0: Boolean, out: String, err: String)
+    def assertSuccess(res: Result, msg: => String)(implicit logger: Logger) = {
+      assert(res.exit0, msg + res.toString)
     }
 
     // tests
@@ -50,24 +49,25 @@ object Main{
       val usageString = "Methods provided by CBT"
       val res = runCbt(path, Seq())
       logger.test(res.toString)
-      assertSuccess(res)
-      assert(res.out == "", "usage " + path +" "+ res.toString)
-      assert(res.err contains usageString, "usage " + path +" "+res.toString)
+      val debugToken = "usage " + path +" "
+      assertSuccess(res,debugToken)
+      assert(res.out == "", debugToken+ res.toString)
+      assert(res.err contains usageString, debugToken+res.toString)
     }
     def compile(path: String)(implicit logger: Logger) = {
       val res = runCbt(path, Seq("compile"))
-      assertSuccess(res)
+      val debugToken = "compile " + path +" "
+      assertSuccess(res,debugToken)
       // assert(res.err == "", res.err) // FIXME: enable this
     }
 
     logger.test( "Running tests " ++ args.toList.toString )
 
-    //usage("nothing")
+    usage("nothing")
     compile("nothing")
-    //usage("multi-build")
+    usage("multi-build")
     compile("multi-build")
     
-
     {
       val noContext = Context(cbtHome ++ "/test/nothing", Seq(), logger)
       val b = new Build(noContext){