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
|
import scala.tools.nsc.Settings
import scala.tools.nsc.interpreter.ILoop
import scala.tools.nsc.settings.ClassPathRepresentationType
import scala.tools.partest._
object Test extends StoreReporterDirectTest {
def code = ???
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 = toCodeInSeparateLines(s":require ${testOutput.path}/$jar", "test.Test.test()")
val output = ILoop.run(codeToRun, settings)
val lines = output.split("\n")
assert {
lines(4).contains("Added") && lines(4).contains("test1.jar")
}
assert {
lines(lines.length-3).contains("testing...")
}
}
def test2(): Unit = {
// should reject jars with conflicting entries
val jar1 = "test1.jar"
val jar2 = "test2.jar"
compileCode(app2, jar2)
val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar2")
val output = ILoop.run(codeToRun, settings)
val lines = output.split("\n")
assert {
lines(4).contains("Added") && lines(4).contains("test1.jar")
}
assert {
lines(lines.length-3).contains("test2.jar") && lines(lines.length-3).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 = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar3", "test.Test3.test()")
val output = ILoop.run(codeToRun, settings)
val lines = output.split("\n")
assert {
lines(4).contains("Added") && lines(4).contains("test1.jar")
}
assert {
lines(lines.length-3).contains("new object in existing package")
}
}
def test4(): Unit = {
// twice the same jar should be rejected
val jar1 = "test1.jar"
val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar1")
val output = ILoop.run(codeToRun, settings)
val lines = output.split("\n")
assert {
lines(4).contains("Added") && lines(4).contains("test1.jar")
}
assert {
lines(lines.length-3).contains("test1.jar") && lines(lines.length-3).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 appoach of using a Java
// classloader to parse .class files in order to read their names.
val jar = "test6.jar"
compileCode(app6, jar)
val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar", "import test6._; new A; new Z")
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()
}
def toCodeInSeparateLines(lines: String*): String = lines mkString "\n"
}
|
