package mill.util
import TestUtil.test
import mill.define.{Cross, Discover}
import mill.{Module, T}
/**
* Example dependency graphs for us to use in our test suite.
*
* The graphs using `test()` live in the `class` and need to be instantiated
* every time you use them, because they are mutable (you can poke at the
* `test`'s `counter`/`failure`/`exception` fields to test various graph
* evaluation scenarios.
*
* The immutable graphs, used for testing discovery & target resolution,
* live in the companion object.
*/
class TestGraphs(){
// single
object singleton extends TestUtil.BaseModule {
val single = test()
}
object bactickIdentifiers extends TestUtil.BaseModule {
val `up-target` = test()
val `a-down-target` = test(`up-target`)
val `invisible&` = test()
object `nested-module` extends TestUtil.BaseModule {
val `nested-target` = test()
}
}
// up---down
object pair extends TestUtil.BaseModule{
val up = test()
val down = test(up)
}
// up---o---down
object anonTriple extends TestUtil.BaseModule {
val up = test()
val down = test(test.anon(up))
}
// left
// / \
// up down
// \ /
// right
object diamond extends TestUtil.BaseModule {
val up = test()
val left = test(up)
val right = test(up)
val down = test(left, right)
}
// o
// / \
// up down
// \ /
// o
object anonDiamond extends TestUtil.BaseModule {
val up = test()
val down = test(test.anon(up), test.anon(up))
}
object defCachedDiamond extends TestUtil.BaseModule {
def up = T{ test() }
def left = T{ test(up) }
def right = T{ test(up) }
def down = T{ test(left, right) }
}
object borkedCachedDiamond2 extends TestUtil.BaseModule {
def up = test()
def left = test(up)
def right = test(up)
def down = test(left, right)
}
object borkedCachedDiamond3 extends TestUtil.BaseModule {
def up = test()
def left = test(up)
def right = test(up)
def down = test(left, right)
}
// o g-----o
// \ \ \
// o o h-----I---o
// \ / \ / \ / \ \
// A---c--o E o-o \ \
// / \ / \ / \ o---J
// o d o--o o / /
// \ / \ / /
// o o---F---o
// / /
// o--B o
object bigSingleTerminal extends TestUtil.BaseModule {
val a = test(test.anon(), test.anon())
val b = test(test.anon())
val e = {
val c = test.anon(a)
val d = test.anon(a)
test(
test.anon(test.anon(), test.anon(c)),
test.anon(test.anon(c, test.anon(d, b)))
)
}
val f = test(test.anon(test.anon(), test.anon(e)))
val i = {
val g = test.anon()
val h = test.anon(g, e)
test(test.anon(g), test.anon(test.anon(h)))
}
val j = test(test.anon(i), test.anon(i, f), test.anon(f))
}
// _ left _
// / \
// task1 -------- right
// _/
// change - task2
object separateGroups extends TestUtil.BaseModule {
val task1 = T.task{ 1 }
def left = T{ task1() }
val change = test()
val task2 = T.task{ change() }
def right = T{ task1() + task2() + left() + 1 }
}
}
object TestGraphs{
// _ left _
// / \
// task -------- right
object triangleTask extends TestUtil.BaseModule {
val task = T.task{ 1 }
def left = T{ task() }
def right = T{ task() + left() + 1 }
}
// _ left
// /
// task -------- right
object multiTerminalGroup extends TestUtil.BaseModule {
val task = T.task{ 1 }
def left = T{ task() }
def right = T{ task() }
}
// _ left _____________
// / \ \
// task1 -------- right ----- task2
object multiTerminalBoundary extends TestUtil.BaseModule {
val task1 = T.task{ 1 }
def left = T{ task1() }
def right = T{ task1() + left() + 1 }
val task2 = T.task{ left() + right() }
}
trait CanNest extends Module{
def single = T{ 1 }
def invisible: Any = T{ 2 }
def invisible2: mill.define.Task[Int] = T{ 3 }
def invisible3: mill.define.Task[_] = T{ 4 }
}
object nestedModule extends TestUtil.BaseModule {
def single = T{ 5 }
def invisible: Any = T{ 6 }
object nested extends Module{
def single = T{ 7 }
def invisible: Any = T{ 8 }
}
object classInstance extends CanNest
}
trait BaseModule extends Module {
def foo = T{ Seq("base") }
def cmd(i: Int) = T.command{ Seq("base" + i) }
}
object canOverrideSuper extends TestUtil.BaseModule with BaseModule {
override def foo = T{ super.foo() ++ Seq("object") }
override def cmd(i: Int) = T.command{ super.cmd(i)() ++ Seq("object" + i) }
override lazy val millDiscover: Discover[this.type] = Discover[this.type]
}
trait TraitWithModule extends Module{ outer =>
object TraitModule extends Module{
def testFrameworks = T{ Seq("mill.UTestFramework") }
def test() = T.command{ ()/*donothing*/ }
}
}
// Make sure nested objects inherited from traits work
object TraitWithModuleObject extends TestUtil.BaseModule with TraitWithModule{
override lazy val millDiscover: Discover[this.type] = Discover[this.type]
}
object nullTasks extends TestUtil.BaseModule{
val nullString: String = null
def nullTask1 = T.task{ nullString }
def nullTask2 = T.task{ nullTask1() }
def nullTarget1 = T{ nullString }
def nullTarget2 = T{ nullTarget1() }
def nullTarget3 = T{ nullTask1() }
def nullTarget4 = T{ nullTask2() }
def nullCommand1() = T.command{ nullString }
def nullCommand2() = T.command{ nullTarget1() }
def nullCommand3() = T.command{ nullTask1() }
def nullCommand4() = T.command{ nullTask2() }
override lazy val millDiscover: Discover[this.type] = Discover[this.type]
}
object singleCross extends TestUtil.BaseModule {
object cross extends mill.Cross[Cross]("210", "211", "212")
class Cross(scalaVersion: String) extends Module{
def suffix = T{ scalaVersion }
}
}
object crossResolved extends TestUtil.BaseModule {
trait MyModule extends Module{
def crossVersion: String
implicit object resolver extends mill.define.Cross.Resolver[MyModule]{
def resolve[V <: MyModule](c: Cross[V]): V = c.itemMap(List(crossVersion))
}
}
object foo extends mill.Cross[FooModule]("2.10", "2.11", "2.12")
class FooModule(val crossVersion: String) extends MyModule{
def suffix = T{ crossVersion }
}
object bar extends mill.Cross[BarModule]("2.10", "2.11", "2.12")
class BarModule(val crossVersion: String) extends MyModule{
def longSuffix = T{ "_" + foo().suffix() }
}
}
object doubleCross extends TestUtil.BaseModule {
val crossMatrix = for{
scalaVersion <- Seq("210", "211", "212")
platform <- Seq("jvm", "js", "native")
if !(platform == "native" && scalaVersion != "212")
} yield (scalaVersion, platform)
object cross extends mill.Cross[Cross](crossMatrix:_*)
class Cross(scalaVersion: String, platform: String) extends Module{
def suffix = T{ scalaVersion + "_" + platform }
}
}
object nestedCrosses extends TestUtil.BaseModule {
object cross extends mill.Cross[Cross]("210", "211", "212")
class Cross(scalaVersion: String) extends mill.Module{
object cross2 extends mill.Cross[Cross]("jvm", "js", "native")
class Cross(platform: String) extends mill.Module{
def suffix = T{ scalaVersion + "_" + platform }
}
}
}
}