`Core` -> `core`, for consistency with SBT naming schemes

`ScalaPlugin` -> `scalalib`, to avoid confusion with Scala compiler plugins

`ScalaModule` -> `module`, to be used via `scalalib.Module`, avoid unnecessary duplication in th name prefix

`plugin` -> `moduledefs`, to more accurately describe what it does (since it includes `Cacher` as well)

5 files changed, 643 insertions, 0 deletions

diff --git a/scalalib/src/test/scala/mill/scalalib/AcyclicTests.scala b/scalalib/src/test/scala/mill/scalalib/AcyclicTests.scala
new file mode 100644
index 00000000..9b68ea70
--- /dev/null
+++ b/scalalib/src/test/scala/mill/scalalib/AcyclicTests.scala
@@ -0,0 +1,78 @@
+package mill.scalalib
+
+import ammonite.ops.ImplicitWd._
+import ammonite.ops._
+import mill.define.Cross
+import mill.discover.Discovered
+import mill.scalalib.publish._
+import utest._
+import mill.util.JsonFormatters._
+import mill.util.TestEvaluator
+object AcyclicBuild{
+  val acyclic =
+    for(crossVersion <- Cross("2.10.6", "2.11.8", "2.12.3", "2.12.4"))
+    yield new SbtModule with PublishModule {outer =>
+      def basePath = AcyclicTests.workspacePath
+      def artifactName = "acyclic"
+      def publishVersion = "0.1.7"
+
+      def pomSettings = PomSettings(
+        description = artifactName(),
+        organization = "com.lihaoyi",
+        url = "https://github.com/lihaoyi/acyclic",
+        licenses = Seq(
+          License("MIT license", "http://www.opensource.org/licenses/mit-license.php")
+        ),
+        scm = SCM(
+          "git://github.com/lihaoyi/acyclic.git",
+          "scm:git://github.com/lihaoyi/acyclic.git"
+        ),
+        developers = Seq(
+          Developer("lihaoyi", "Li Haoyi","https://github.com/lihaoyi")
+        )
+      )
+
+      def scalaVersion = crossVersion
+      def ivyDeps = Seq(
+        Dep.Java("org.scala-lang", "scala-compiler", scalaVersion())
+      )
+      object test extends this.Tests{
+        def forkWorkingDir = pwd/'scalalib/'src/'test/'resource/'acyclic
+        def ivyDeps = Seq(
+          Dep("com.lihaoyi", "utest", "0.6.0")
+        )
+        def testFramework = "utest.runner.Framework"
+      }
+    }
+}
+object AcyclicTests extends TestSuite{
+  val workspacePath = pwd / 'target / 'workspace / 'acyclic
+  val srcPath = pwd / 'scalalib / 'src / 'test / 'resource / 'acyclic
+  val tests = Tests{
+    rm(workspacePath)
+    mkdir(workspacePath/up)
+    cp(srcPath, workspacePath)
+    val mapping = Discovered.mapping(AcyclicBuild)
+    val eval = new TestEvaluator(mapping, workspacePath)
+
+    def check(scalaVersion: String) = {
+      // We can compile
+      val Right((pathRef, evalCount)) = eval(AcyclicBuild.acyclic(scalaVersion).compile)
+      val outputPath = pathRef.classes.path
+      val outputFiles = ls.rec(outputPath)
+      assert(
+        evalCount > 0,
+        outputFiles.contains(outputPath/'acyclic/'plugin/"GraphAnalysis.class"),
+        outputFiles.contains(outputPath/'acyclic/'plugin/"PluginPhase.class")
+      )
+
+      // Compilation is cached
+      val Right((_, evalCount2)) = eval(AcyclicBuild.acyclic(scalaVersion).compile)
+      assert(evalCount2 == 0)
+    }
+
+    'scala211 - check("2.11.8")
+    'scala2123 - check("2.12.3")
+
+  }
+}
diff --git a/scalalib/src/test/scala/mill/scalalib/BetterFilesTests.scala b/scalalib/src/test/scala/mill/scalalib/BetterFilesTests.scala
new file mode 100644
index 00000000..c3004f7b
--- /dev/null
+++ b/scalalib/src/test/scala/mill/scalalib/BetterFilesTests.scala
@@ -0,0 +1,111 @@
+package mill.scalalib
+
+import ammonite.ops.ImplicitWd._
+import ammonite.ops._
+import mill.discover.Discovered
+import utest._
+import mill.util.JsonFormatters._
+import mill.util.TestEvaluator
+
+object BetterFilesBuild{
+  trait BetterFilesModule extends SbtModule{ outer =>
+    def scalaVersion = "2.12.4"
+    def scalacOptions = Seq(
+      "-deprecation",                      // Emit warning and location for usages of deprecated APIs.
+      "-encoding", "utf-8",                // Specify character encoding used by source files.
+      "-explaintypes",                     // Explain type errors in more detail.
+      "-feature",                          // Emit warning and location for usages of features that should be imported explicitly.
+      "-language:existentials",            // Existential types (besides wildcard types) can be written and inferred
+      "-language:experimental.macros",     // Allow macro definition (besides implementation and application)
+      "-language:higherKinds",             // Allow higher-kinded types
+      "-language:implicitConversions",     // Allow definition of implicit functions called views
+      "-unchecked",                        // Enable additional warnings where generated code depends on assumptions.
+      "-Xcheckinit",                       // Wrap field accessors to throw an exception on uninitialized access.
+      "-Xfatal-warnings",                  // Fail the compilation if there are any warnings.
+      "-Xfuture",                          // Turn on future language features.
+      "-Xlint:adapted-args",               // Warn if an argument list is modified to match the receiver.
+      "-Xlint:by-name-right-associative",  // By-name parameter of right associative operator.
+      "-Xlint:constant",                   // Evaluation of a constant arithmetic expression results in an error.
+      "-Xlint:delayedinit-select",         // Selecting member of DelayedInit.
+      "-Xlint:doc-detached",               // A Scaladoc comment appears to be detached from its element.
+      "-Xlint:inaccessible",               // Warn about inaccessible types in method signatures.
+      "-Xlint:infer-any",                  // Warn when a type argument is inferred to be `Any`.
+      "-Xlint:missing-interpolator",       // A string literal appears to be missing an interpolator id.
+      "-Xlint:nullary-override",           // Warn when non-nullary `def f()' overrides nullary `def f'.
+      "-Xlint:nullary-unit",               // Warn when nullary methods return Unit.
+      "-Xlint:option-implicit",            // Option.apply used implicit view.
+      "-Xlint:package-object-classes",     // Class or object defined in package object.
+      "-Xlint:poly-implicit-overload",     // Parameterized overloaded implicit methods are not visible as view bounds.
+      "-Xlint:private-shadow",             // A private field (or class parameter) shadows a superclass field.
+      "-Xlint:stars-align",                // Pattern sequence wildcard must align with sequence component.
+      "-Xlint:type-parameter-shadow",      // A local type parameter shadows a type already in scope.
+      "-Xlint:unsound-match",              // Pattern match may not be typesafe.
+      "-Yno-adapted-args",                 // Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver.
+      "-Ypartial-unification",             // Enable partial unification in type constructor inference
+      "-Ywarn-dead-code",                  // Warn when dead code is identified.
+      "-Ywarn-extra-implicit",             // Warn when more than one implicit parameter section is defined.
+      "-Ywarn-inaccessible",               // Warn about inaccessible types in method signatures.
+      "-Ywarn-infer-any",                  // Warn when a type argument is inferred to be `Any`.
+      "-Ywarn-nullary-override",           // Warn when non-nullary `def f()' overrides nullary `def f'.
+      "-Ywarn-nullary-unit",               // Warn when nullary methods return Unit.
+      "-Ywarn-numeric-widen",              // Warn when numerics are widened.
+      "-Ywarn-unused:implicits",           // Warn if an implicit parameter is unused.
+      "-Ywarn-unused:imports",             // Warn if an import selector is not referenced.
+      "-Ywarn-unused:locals",              // Warn if a local definition is unused.
+      "-Ywarn-unused:params",              // Warn if a value parameter is unused.
+      "-Ywarn-unused:patvars",             // Warn if a variable bound in a pattern is unused.
+      "-Ywarn-unused:privates",            // Warn if a private member is unused.
+      "-Ywarn-value-discard"               // Warn when non-Unit expression results are unused.
+    )
+    override def javacOptions = Seq("-source", "1.8", "-target", "1.8", "-Xlint")
+    object test extends this.Tests{
+      def projectDeps =
+        if (this == Core.test) Seq(Core)
+        else Seq(outer, Core.test)
+      def ivyDeps = Seq(Dep("org.scalatest", "scalatest", "3.0.4"))
+      def testFramework = "org.scalatest.tools.Framework"
+    }
+  }
+  object Core extends BetterFilesModule{
+    def basePath = BetterFilesTests.srcPath/"core"
+  }
+  object Akka extends BetterFilesModule{
+    def projectDeps = Seq(Core)
+    def basePath = BetterFilesTests.srcPath/"akka"
+    def ivyDeps = Seq(Dep("com.typesafe.akka", "akka-actor", "2.5.6"))
+  }
+  object ShapelessScanner extends BetterFilesModule{
+    def projectDeps = Seq(Core)
+    def basePath = BetterFilesTests.srcPath/"shapeless"
+    def ivyDeps = Seq(Dep("com.chuusai", "shapeless", "2.3.2"))
+  }
+  object Benchmarks extends BetterFilesModule{
+    def projectDeps = Seq(Core)
+    def basePath = BetterFilesTests.srcPath/"benchmarks"
+    def ivyDeps = Seq(
+      Dep.Java("commons-io", "commons-io", "2.5")
+      // "fastjavaio" % "fastjavaio" % "1.0" from "https://github.com/williamfiset/FastJavaIO/releases/download/v1.0/fastjavaio.jar"
+    )
+  }
+}
+object BetterFilesTests extends TestSuite{
+  val workspacePath = pwd / 'target / 'workspace / "better-files"
+  val srcPath = pwd / 'scalalib / 'src / 'test / 'resource / "better-files"
+  val tests = Tests{
+    rm(workspacePath)
+    mkdir(workspacePath/up)
+    cp(srcPath, workspacePath)
+    val mapping = Discovered.mapping(BetterFilesBuild)
+    val eval = new TestEvaluator(mapping, workspacePath)
+
+    'test - {
+
+      val Right(_) = eval(BetterFilesBuild.Core.test.test())
+      val Right(_) = eval(BetterFilesBuild.Akka.test.compile)
+      val Right(_) = eval(BetterFilesBuild.ShapelessScanner.test.compile)
+      // Doesn't work yet, need to support curling down a jar and caching it
+      val Left(_) = eval(BetterFilesBuild.Benchmarks.test.test())
+    }
+
+  }
+}
diff --git a/scalalib/src/test/scala/mill/scalalib/HelloWorldTests.scala b/scalalib/src/test/scala/mill/scalalib/HelloWorldTests.scala
new file mode 100644
index 00000000..aafd980a
--- /dev/null
+++ b/scalalib/src/test/scala/mill/scalalib/HelloWorldTests.scala
@@ -0,0 +1,323 @@
+package mill.scalalib
+
+import java.util.jar.JarFile
+
+import ammonite.ops._
+import ammonite.ops.ImplicitWd._
+import mill._
+import mill.define.{Cross, Target}
+import mill.discover.Discovered
+import mill.eval.{Evaluator, Result}
+import mill.scalalib.publish._
+import mill.util.TestEvaluator
+import sbt.internal.inc.CompileFailed
+import utest._
+
+import scala.collection.JavaConverters._
+
+trait HelloWorldModule extends scalalib.Module {
+  def scalaVersion = "2.12.4"
+  def basePath = HelloWorldTests.workspacePath
+}
+
+object HelloWorld extends HelloWorldModule
+object CrossHelloWorld extends mill.Module{
+  val cross =
+    for(v <- Cross("2.10.6", "2.11.11", "2.12.3", "2.12.4"))
+    yield new HelloWorldModule {
+      def scalaVersion = v
+    }
+}
+
+object HelloWorldWithMain extends HelloWorldModule {
+  def mainClass = Some("Main")
+}
+
+object HelloWorldWarnUnused extends HelloWorldModule {
+  def scalacOptions = T(Seq("-Ywarn-unused"))
+}
+
+object HelloWorldFatalWarnings extends HelloWorldModule {
+  def scalacOptions = T(Seq("-Ywarn-unused", "-Xfatal-warnings"))
+}
+
+object HelloWorldWithPublish extends HelloWorldModule with PublishModule {
+  def artifactName = "hello-world"
+  def publishVersion = "0.0.1"
+
+  def pomSettings = PomSettings(
+    organization = "com.lihaoyi",
+    description = "hello world ready for real world publishing",
+    url = "https://github.com/lihaoyi/hello-world-publish",
+    licenses = Seq(
+      License("Apache License, Version 2.0",
+              "http://www.apache.org/licenses/LICENSE-2.0")),
+    scm = SCM(
+      "https://github.com/lihaoyi/hello-world-publish",
+      "scm:git:https://github.com/lihaoyi/hello-world-publish"
+    ),
+    developers =
+      Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
+  )
+}
+object HelloWorldScalaOverride extends HelloWorldModule {
+  override def scalaVersion: Target[String] = "2.11.11"
+}
+object HelloWorldTests extends TestSuite {
+
+  val srcPath = pwd / 'scalalib / 'src / 'test / 'resource / "hello-world"
+  val workspacePath = pwd / 'target / 'workspace / "hello-world"
+  val mainObject = workspacePath / 'src / 'main / 'scala / "Main.scala"
+
+
+
+
+  val helloWorldEvaluator = new TestEvaluator(
+    Discovered.mapping(HelloWorld),
+    workspacePath
+  )
+  val helloWorldWithMainEvaluator = new TestEvaluator(
+    Discovered.mapping(HelloWorldWithMain),
+    workspacePath
+  )
+  val helloWorldFatalEvaluator = new TestEvaluator(
+    Discovered.mapping(HelloWorldFatalWarnings),
+    workspacePath
+  )
+  val helloWorldOverrideEvaluator = new TestEvaluator(
+    Discovered.mapping(HelloWorldScalaOverride),
+    workspacePath
+  )
+  val helloWorldCrossEvaluator = new TestEvaluator(
+    Discovered.mapping(CrossHelloWorld),
+    workspacePath
+  )
+
+
+  def tests: Tests = Tests {
+    prepareWorkspace()
+    'scalaVersion - {
+      'fromBuild - {
+        val Right((result, evalCount)) = helloWorldEvaluator(HelloWorld.scalaVersion)
+
+        assert(
+          result == "2.12.4",
+          evalCount > 0
+        )
+      }
+      'override - {
+        val Right((result, evalCount)) = helloWorldOverrideEvaluator(HelloWorldScalaOverride.scalaVersion)
+
+        assert(
+          result == "2.11.11",
+          evalCount > 0
+        )
+      }
+    }
+    'scalacOptions - {
+      'emptyByDefault - {
+        val Right((result, evalCount)) = helloWorldEvaluator(HelloWorld.scalacOptions)
+
+        assert(
+          result.isEmpty,
+          evalCount > 0
+        )
+      }
+      'override - {
+        val Right((result, evalCount)) = helloWorldFatalEvaluator(HelloWorldFatalWarnings.scalacOptions)
+
+        assert(
+          result == Seq("-Ywarn-unused", "-Xfatal-warnings"),
+          evalCount > 0
+        )
+      }
+    }
+    'compile - {
+      'fromScratch - {
+        val Right((result, evalCount)) = helloWorldEvaluator(HelloWorld.compile)
+
+        val outPath = result.classes.path
+        val analysisFile = result.analysisFile
+        val outputFiles = ls.rec(outPath)
+        val expectedClassfiles = compileClassfiles.map(workspacePath / 'compile / 'dest / 'classes / _)
+        assert(
+          outPath == workspacePath / 'compile / 'dest / 'classes,
+          exists(analysisFile),
+          outputFiles.nonEmpty,
+          outputFiles.forall(expectedClassfiles.contains),
+          evalCount > 0
+        )
+
+        // don't recompile if nothing changed
+        val Right((_, unchangedEvalCount)) = helloWorldEvaluator(HelloWorld.compile)
+        assert(unchangedEvalCount == 0)
+      }
+      'recompileOnChange - {
+        val Right((_, freshCount)) = helloWorldEvaluator(HelloWorld.compile)
+        assert(freshCount > 0)
+
+        write.append(mainObject, "\n")
+
+        val Right((_, incCompileCount)) = helloWorldEvaluator(HelloWorld.compile)
+        assert(incCompileCount > 0, incCompileCount < freshCount)
+      }
+      'failOnError - {
+        write.append(mainObject, "val x: ")
+
+        val Left(Result.Exception(err)) = helloWorldEvaluator(HelloWorld.compile)
+
+        assert(err.isInstanceOf[CompileFailed])
+
+        val paths = Evaluator.resolveDestPaths(
+          workspacePath,
+          helloWorldEvaluator.evaluator.mapping.targets(HelloWorld.compile)
+        )
+
+        assert(
+          ls.rec(paths.dest / 'classes).isEmpty,
+          !exists(paths.meta)
+        )
+        // Works when fixed
+        write.over(mainObject, read(mainObject).dropRight("val x: ".length))
+
+        val Right((result, evalCount)) = helloWorldEvaluator(HelloWorld.compile)
+      }
+      'passScalacOptions - {
+        // compilation fails because of "-Xfatal-warnings" flag
+        val Left(Result.Exception(err)) = helloWorldFatalEvaluator(HelloWorldFatalWarnings.compile)
+
+        assert(err.isInstanceOf[CompileFailed])
+      }
+    }
+    'runMain - {
+      'runMainObject - {
+        val Right((_, evalCount)) = helloWorldEvaluator(HelloWorld.runMain("Main"))
+
+        assert(evalCount > 0)
+
+        val runResult = workspacePath / "hello-mill"
+        assert(
+          exists(runResult),
+          read(runResult) == "hello rockjam, your age is: 25"
+        )
+      }
+      'runCross{
+        def cross(v: String) {
+
+          val Right((_, evalCount)) = helloWorldCrossEvaluator(
+            CrossHelloWorld.cross(v).runMain("Main")
+          )
+
+          assert(evalCount > 0)
+
+          val runResult = workspacePath / "hello-mill"
+          assert(
+            exists(runResult),
+            read(runResult) == "hello rockjam, your age is: 25"
+          )
+        }
+        'v210 - cross("2.10.6")
+        'v211 - cross("2.11.11")
+        'v2123 - cross("2.12.3")
+        'v2124 - cross("2.12.4")
+      }
+
+
+      'notRunInvalidMainObject - {
+        val Left(Result.Exception(err)) = helloWorldEvaluator(HelloWorld.runMain("Invalid"))
+
+        assert(
+          err.isInstanceOf[InteractiveShelloutException]
+        )
+      }
+      'notRunWhenComplileFailed - {
+        write.append(mainObject, "val x: ")
+
+        val Left(Result.Exception(err)) = helloWorldEvaluator(HelloWorld.runMain("Main"))
+
+        assert(
+          err.isInstanceOf[CompileFailed]
+        )
+      }
+    }
+    'run - {
+      'runIfMainClassProvided - {
+        val Right((_, evalCount)) = helloWorldWithMainEvaluator(HelloWorldWithMain.run())
+
+        assert(evalCount > 0)
+
+        val runResult = workspacePath / "hello-mill"
+        assert(
+          exists(runResult),
+          read(runResult) == "hello rockjam, your age is: 25"
+        )
+      }
+      'notRunWithoutMainClass - {
+        val Left(Result.Exception(err)) = helloWorldEvaluator(HelloWorld.run())
+
+        assert(
+          err.isInstanceOf[RuntimeException]
+        )
+      }
+    }
+    'jar - {
+      'nonEmpty - {
+        val Right((result, evalCount)) = helloWorldEvaluator(HelloWorld.jar)
+
+        assert(
+          exists(result.path),
+          evalCount > 0
+        )
+
+        val entries = new JarFile(result.path.toIO).entries().asScala.map(_.getName).toSet
+
+        val manifestFiles = Seq[RelPath](
+          "META-INF" / "MANIFEST.MF"
+        )
+        val expectedFiles = compileClassfiles ++ manifestFiles
+
+        assert(
+          entries.nonEmpty,
+          entries == expectedFiles.map(_.toString()).toSet
+        )
+      }
+      'runJar - {
+        val Right((result, evalCount)) = helloWorldWithMainEvaluator(HelloWorldWithMain.jar)
+
+        assert(
+          exists(result.path),
+          evalCount > 0
+        )
+
+        %("scala", result.path)
+
+        val runResult = workspacePath / "hello-mill"
+        assert(
+          exists(runResult),
+          read(runResult) == "hello rockjam, your age is: 25"
+        )
+      }
+      'logOutputToFile {
+        helloWorldEvaluator(HelloWorld.compile)
+
+        val logFile = workspacePath / 'compile / 'log
+        assert(exists(logFile))
+      }
+    }
+  }
+
+  def compileClassfiles = Seq[RelPath](
+    "Main.class",
+    "Main$.class",
+    "Main$delayedInit$body.class",
+    "Person.class",
+    "Person$.class"
+  )
+
+  def prepareWorkspace(): Unit = {
+    rm(workspacePath)
+    mkdir(workspacePath / up)
+    cp(srcPath, workspacePath)
+  }
+
+}
diff --git a/scalalib/src/test/scala/mill/scalalib/JawnTests.scala b/scalalib/src/test/scala/mill/scalalib/JawnTests.scala
new file mode 100644
index 00000000..71e4d506
--- /dev/null
+++ b/scalalib/src/test/scala/mill/scalalib/JawnTests.scala
@@ -0,0 +1,92 @@
+package mill.scalalib
+
+import ammonite.ops.ImplicitWd._
+import ammonite.ops._
+import mill.{Module, scalalib}
+import mill.define.{Cross, Task}
+import mill.discover.Discovered
+import mill.eval.Result
+import utest._
+import mill.util.JsonFormatters._
+import mill.util.TestEvaluator
+
+object JawnBuild{
+  val Jawn = Cross("2.10.6", "2.11.11", "2.12.3").map(new Jawn(_))
+  class Jawn(crossVersion: String) extends mill.Module{
+    trait JawnModule extends scalalib.SbtModule{ outer =>
+      def scalaVersion = crossVersion
+      def scalacOptions = Seq(
+        "-deprecation",
+        "-optimize",
+        "-unchecked"
+      )
+      def testProjectDeps: Seq[TestModule] = Nil
+      object test extends this.Tests{
+        def projectDeps = super.projectDeps ++ testProjectDeps
+        def ivyDeps = Seq(
+          Dep("org.scalatest", "scalatest", "3.0.3"),
+          Dep("org.scalacheck", "scalacheck", "1.13.5")
+        )
+        def testFramework = "org.scalatest.tools.Framework"
+      }
+    }
+    object Parser extends JawnModule{
+      def basePath = JawnTests.srcPath/"parser"
+    }
+    object Util extends JawnModule{
+      def projectDeps = Seq(Parser)
+      def testProjectDeps = Seq(Parser.test)
+      def basePath = JawnTests.srcPath/"util"
+    }
+    object Ast extends JawnModule{
+      def projectDeps = Seq(Parser, Util)
+      def testProjectDeps = Seq(Parser.test, Util.test)
+      def basePath = JawnTests.srcPath/"ast"
+    }
+    class Support(name: String, ivyDeps0: Dep*) extends JawnModule{
+      def projectDeps = Seq[Module](Parser)
+      def basePath = JawnTests.srcPath/"support"/"argonaut"
+      def ivyDeps = ivyDeps0
+    }
+    object Argonaut extends Support("argonaut", Dep("io.argonaut", "argonaut", "6.2"))
+    object Json4s extends Support("json4s", Dep("org.json4s", "json4s-ast", "3.5.2"))
+
+    object Play extends Support("play"){
+      def ivyDeps = mill.T{
+        scalaBinaryVersion() match{
+          case "2.10" => Seq(Dep("com.typesafe.play", "play-json", "2.4.11"))
+          case "2.11" => Seq(Dep("com.typesafe.play", "play-json", "2.5.15"))
+          case _ => Seq(Dep("com.typesafe.play", "play-json", "2.6.0"))
+        }
+      }
+    }
+
+    object Rojoma extends Support("rojoma", Dep("com.rojoma", "rojoma-json", "2.4.3"))
+    object RojomaV3 extends Support("rojoma-v3", Dep("com.rojoma", "rojoma-json-v3", "3.7.2"))
+    object Spray extends Support("spray", Dep("io.spray", "spray-json", "1.3.3"))
+  }
+  
+}
+object JawnTests extends TestSuite{
+  val workspacePath = pwd / 'target / 'workspace / "jawn"
+  val srcPath = pwd / 'scalalib / 'src / 'test / 'resource / "jawn"
+  val tests = Tests{
+    rm(workspacePath)
+    mkdir(workspacePath/up)
+    cp(srcPath, workspacePath)
+    val mapping = Discovered.mapping(JawnBuild)
+    val eval = new TestEvaluator(mapping, workspacePath)
+
+    'test - {
+      def compileOutput = workspacePath / 'jawn / "2.12.3" / 'Parser / 'compile
+      def testCompileOutput = workspacePath / 'jawn / "2.12.3" / 'Parser / 'test / 'compile
+      assert(!exists(compileOutput), !exists(testCompileOutput))
+      val Right(_) = eval(JawnBuild.Jawn("2.12.3").Parser.test.test())
+      assert(
+        ls.rec(compileOutput).exists(_.last == "AsyncParser.class"),
+        ls.rec(testCompileOutput).exists(_.last == "CharBuilderSpec.class")
+      )
+    }
+
+  }
+}
diff --git a/scalalib/src/test/scala/mill/scalalib/ResolveDepsTests.scala b/scalalib/src/test/scala/mill/scalalib/ResolveDepsTests.scala
new file mode 100644
index 00000000..c5a05d02
--- /dev/null
+++ b/scalalib/src/test/scala/mill/scalalib/ResolveDepsTests.scala
@@ -0,0 +1,39 @@
+package mill.scalalib
+
+import coursier.Cache
+import coursier.maven.MavenRepository
+import mill.eval.Result.{Failure, Success}
+import mill.eval.{PathRef, Result}
+import utest._
+
+object ResolveDepsTests extends TestSuite {
+  val repos = Seq(Cache.ivy2Local, MavenRepository("https://repo1.maven.org/maven2"))
+
+  def evalDeps(deps: Seq[Dep]): Result[Seq[PathRef]] = Lib.resolveDependencies(repos, "2.12.4", "2.12", deps)
+
+  val tests = Tests {
+    'resolveValidDeps - {
+      val deps = Seq(Dep("com.lihaoyi", "pprint", "0.5.3"))
+      val Success(paths) = evalDeps(deps)
+      assert(paths.nonEmpty)
+    }
+
+    'errOnInvalidOrgDeps - {
+      val deps = Seq(Dep("xxx.yyy.invalid", "pprint", "0.5.3"))
+      val Failure(errMsg) = evalDeps(deps)
+      assert(errMsg.contains("xxx.yyy.invalid"))
+    }
+
+    'errOnInvalidVersionDeps - {
+      val deps = Seq(Dep("com.lihaoyi", "pprint", "invalid.version.num"))
+      val Failure(errMsg) = evalDeps(deps)
+      assert(errMsg.contains("invalid.version.num"))
+    }
+
+    'errOnPartialSuccess - {
+      val deps = Seq(Dep("com.lihaoyi", "pprint", "0.5.3"), Dep("fake", "fake", "fake"))
+      val Failure(errMsg) = evalDeps(deps)
+      assert(errMsg.contains("fake"))
+    }
+  }
+}