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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
import scala.tools.nsc.Settings
import scala.tools.nsc.interpreter.{ ILoop, replProps }
import scala.tools.nsc.settings.ClassPathRepresentationType
import scala.tools.partest._
object Test extends StoreReporterDirectTest {
def code = ???
lazy val headerLength = replProps.welcome.lines.size
lazy val promptLength = replProps.prompt.lines.size - 1 // extra newlines
def compileCode(code: String, jarFileName: String) = {
val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
compileString(newCompiler("-cp", classpath, "-d", s"${testOutput.path}/$jarFileName"))(code)
}
// TODO flat classpath doesn't support the classpath invalidation yet so we force using the recursive one
// it's the only test which needed such a workaround
override def settings = {
val settings = new Settings
settings.YclasspathImpl.value = ClassPathRepresentationType.Recursive
settings
}
def app1 = """
package test
object Test extends App {
def test(): Unit = {
println("testing...")
}
}"""
def app2 = """
package test
object Test extends App {
def test(): Unit = {
println("testing differently...")
}
}"""
def app3 = """
package test
object Test3 extends App {
def test(): Unit = {
println("new object in existing package")
}
}"""
def app6 = """
package test6
class A extends Test { println("created test6.A") }
class Z extends Test { println("created test6.Z") }
trait Test"""
def test1(): Unit = {
val jar = "test1.jar"
compileCode(app1, jar)
val codeToRun = s"""
|:require ${testOutput.path}/$jar
|test.Test.test()
|""".stripMargin.trim
val output = ILoop.run(codeToRun, settings)
var lines = output.lines.drop(headerLength)
lines = lines drop promptLength
val added = lines.next
assert (
added.contains("Added") && added.contains("test1.jar"),
s"[${added}] in [${output.lines.mkString("/")}]"
)
lines = lines drop promptLength
assert {
lines.next.contains("testing...")
}
}
def test2(): Unit = {
// should reject jars with conflicting entries
val jar1 = "test1.jar"
val jar2 = "test2.jar"
compileCode(app2, jar2)
val codeToRun = s"""
|:require ${testOutput.path}/$jar1
|:require ${testOutput.path}/$jar2
|""".stripMargin.trim
val output = ILoop.run(codeToRun, settings)
var lines = output.lines.drop(headerLength)
lines = lines drop promptLength
val added = lines.next
assert {
added.contains("Added") && added.contains("test1.jar")
}
lines = lines drop promptLength
val msg = lines.next
assert {
msg.contains("test2.jar") && msg.contains("existing classpath entries conflict")
}
}
def test3(): Unit = {
// should accept jars with overlapping packages, but no conflicts
val jar1 = "test1.jar"
val jar3 = "test3.jar"
compileCode(app3, jar3)
val codeToRun = s"""
|:require ${testOutput.path}/$jar1
|:require ${testOutput.path}/$jar3
|test.Test3.test()
|""".stripMargin.trim
val output = ILoop.run(codeToRun, settings)
var lines = output.lines.drop(headerLength)
lines = lines drop promptLength
val added = lines.next
assert {
added.contains("Added") && added.contains("test1.jar")
}
lines = lines drop (2 * promptLength + 1)
assert {
lines.next.contains("new object in existing package")
}
}
def test4(): Unit = {
// twice the same jar should be rejected
val jar1 = "test1.jar"
val codeToRun = s"""
|:require ${testOutput.path}/$jar1
|:require ${testOutput.path}/$jar1
|""".stripMargin.trim
val output = ILoop.run(codeToRun, settings)
var lines = output.lines.drop(headerLength)
lines = lines drop promptLength
val added = lines.next
assert {
added.contains("Added") && added.contains("test1.jar")
}
lines = lines drop promptLength
val msg = lines.next
assert {
msg.contains("test1.jar") && msg.contains("existing classpath entries conflict")
}
}
def test5(): Unit = {
val codeToRun = ":require /does/not/exist.jar"
val output = ILoop.run(codeToRun, settings)
assert(!output.contains("NullPointerException"), output)
assert(output.contains("Cannot load '/does/not/exist.jar'"), output)
}
def test6(): Unit = {
// Avoid java.lang.NoClassDefFoundError triggered by the old approach of using a Java
// classloader to parse .class files in order to read their names.
val jar = "test6.jar"
compileCode(app6, jar)
val codeToRun = s"""
|:require ${testOutput.path}/$jar
|import test6._; new A; new Z
|""".stripMargin.trim
val output = ILoop.run(codeToRun, settings)
assert(output.contains("created test6.A"), output)
assert(output.contains("created test6.Z"), output)
}
def show(): Unit = {
test1()
test2()
test3()
test4()
test5()
test6()
}
}
|
