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
118
119
120
121
122
123
124
125
126
127
|
package forge
import utest._
import Target.test
import java.nio.{file => jnio}
object ForgeTests extends TestSuite{
val tests = Tests{
val evaluator = new Evaluator(jnio.Paths.get("target/workspace"), implicitly)
object Singleton {
val single = T{ test() }
}
object Pair {
val up = T{ test() }
val down = T{ test(up) }
}
object AnonTriple{
val up = T{ test() }
val down = T{ test(test(up)) }
}
object Diamond{
val up = T{ test() }
val left = T{ test(up) }
val right = T{ test(up) }
val down = T{ test(left, right) }
}
object AnonDiamond{
val up = T{ test() }
val down = T{ test(test(up), test(up)) }
}
'topoSortedTransitiveTargets - {
def check(targets: Seq[Target[_]], expected: Seq[Target[_]]) = {
val result = Evaluator.topoSortedTransitiveTargets(targets)
assert(result == expected)
}
'singleton - check(
targets = Seq(Singleton.single),
expected = Seq(Singleton.single)
)
'pair - check(
targets = Seq(Pair.down),
expected = Seq(Pair.up, Pair.down)
)
'anonTriple - check(
targets = Seq(AnonTriple.down),
expected = Seq(AnonTriple.up, AnonTriple.down.inputs(0), AnonTriple.down)
)
'diamond - check(
targets = Seq(Diamond.down),
expected = Seq(Diamond.up, Diamond.left, Diamond.right, Diamond.down)
)
'anonDiamond - check(
targets = Seq(Diamond.down),
expected = Seq(
Diamond.up,
Diamond.down.inputs(0),
Diamond.down.inputs(1),
Diamond.down
)
)
}
'evaluate - {
def check(targets: Seq[Target[_]],
values: Seq[Any],
evaluated: Seq[Target[_]]) = {
val Evaluator.Results(returnedValues, returnedEvaluated) = evaluator.evaluate(targets)
assert(
returnedValues == values,
returnedEvaluated == evaluated
)
}
'singleton - {
import Singleton._
// First time the target is evaluated
check(Seq(single), values = Seq(0), evaluated = Seq(single))
// Second time the value is already cached, so no evaluation needed
check(Seq(single), values = Seq(0), evaluated = Seq())
single.counter += 1
// After incrementing the counter, it forces re-evaluation
check(Seq(single), values = Seq(1), evaluated = Seq(single))
// Then it's cached again
check(Seq(single), values = Seq(1), evaluated = Seq())
}
'pair - {
import Pair._
check(Seq(down), values = Seq(0), evaluated = Seq(up, down))
check(Seq(down), values = Seq(0), evaluated = Seq())
down.counter += 1
check(Seq(down), values = Seq(1), evaluated = Seq(down))
check(Seq(down), values = Seq(1), evaluated = Seq())
up.counter += 1
check(Seq(down), values = Seq(2), evaluated = Seq(up, down))
check(Seq(down), values = Seq(2), evaluated = Seq())
}
'anonTriple - {
import AnonTriple._
val middle = down.inputs(0)
check(Seq(down), values = Seq(0), evaluated = Seq(up, middle, down))
check(Seq(down), values = Seq(0), evaluated = Seq())
down.counter += 1
check(Seq(down), values = Seq(1), evaluated = Seq(middle, down))
check(Seq(down), values = Seq(1), evaluated = Seq())
up.counter += 1
check(Seq(down), values = Seq(2), evaluated = Seq(up, middle, down))
check(Seq(down), values = Seq(2), evaluated = Seq())
}
}
// 'full - {
// val sourceRoot = Target.path(jnio.Paths.get("src/test/resources/example/src"))
// val resourceRoot = Target.path(jnio.Paths.get("src/test/resources/example/resources"))
// val allSources = list(sourceRoot)
// val classFiles = compileAll(allSources)
// val jar = jarUp(resourceRoot, classFiles)
// Evaluator.apply(jar, jnio.Paths.get("target/workspace"))
// }
}
}
|
