1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
package mill.discover
import java.io.InputStreamReader
import ammonite.main.Router.{ArgSig, EntryPoint}
import utest._
import mill.{Module, T}
import mill.discover.Mirror.Segment.Label
import mill.util.TestGraphs.{TraitWithModuleObject, nestedModule}
object DiscoveredTests extends TestSuite{
val tests = Tests{
'targets - {
val discovered = Discovered.make[nestedModule.type]
def flatten(h: Mirror[nestedModule.type, _]): Seq[Any] = {
h.node(nestedModule, Nil) :: h.children.flatMap{case (label, c) => flatten(c)}
}
val flattenedHierarchy = flatten(discovered.mirror)
val expectedHierarchy = Seq(
nestedModule,
nestedModule.classInstance,
nestedModule.nested
)
assert(flattenedHierarchy == expectedHierarchy)
val mapped = discovered.targets(nestedModule).map(x => x.segments -> x.target)
val expected = Seq(
(List(Label("classInstance"), Label("single")), nestedModule.classInstance.single),
(List(Label("nested"), Label("single")), nestedModule.nested.single),
(List(Label("single")), nestedModule.single)
)
assert(mapped.toSet == expected.toSet)
}
'traitWithModule - {
val discovered = Discovered.make[TraitWithModuleObject.type]
val mapped = discovered.targets(TraitWithModuleObject).map(x => x.segments -> x.target)
val expected = Seq(
(
List(Label("TraitModule"), Label("testFramework")),
TraitWithModuleObject.TraitModule.testFramework
)
)
assert(mapped == expected)
}
'commands - {
object outer {
def hello() = T.command{
println("Hello")
}
def echoPair(prefix: String, suffix: String) = T.command{
println(prefix + " " + suffix)
}
object nested extends Module{
def inner(x: Int) = T.command{
println(x)
}
}
}
val discovered = Discovered.make[outer.type]
val outerCommands = discovered.mirror.commands
assertMatch(outerCommands){case Seq(
EntryPoint("hello", Nil, None, false, _),
EntryPoint("echoPair",
List(ArgSig("prefix", "String", None, None), ArgSig("suffix", "String", None, None)),
None,
false,
_
)
) =>}
val innerCommands = discovered.mirror
.children
.flatMap(_._2.commands.asInstanceOf[Seq[EntryPoint[_]]])
assertMatch(innerCommands){case Seq(
EntryPoint("inner", _, None, false, _),
) =>}
}
'compileError - {
'unserializableTarget - {
object outer extends Module {
def single = mill.T{ new InputStreamReader(System.in) }
}
val error = compileError("Discovered.make[outer.type]")
assert(
error.msg.contains("uPickle does not know how to read"),
error.pos.contains("def single = mill.T{ new InputStreamReader(System.in) }")
)
}
'unreadableCommand - {
object outer extends Module {
def single(in: InputStreamReader) = mill.T.command{ println(123) }
}
val error = compileError("Discovered.make[outer.type]")
assert(
error.msg.contains("could not find implicit value"),
error.pos.contains("def single(in: InputStreamReader) = mill.T.command{ println(123) }")
)
}
}
}
}
|
