Skip to content

Commit fc86cb2

Browse files
OlivierBlanvillainOlivierBlanvillain
committed
Dupliate jvm/test to js/test, commenting unlinkable parts
1 parent a52ca9c commit fc86cb2

File tree

7 files changed

+1540
-0
lines changed

7 files changed

+1540
-0
lines changed

‎xml/js/src/test/scala/scala/xml/CompilerErrors.scala‎

Lines changed: 202 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,202 @@
1+
// package scala.xml
2+
3+
// import org.junit.Test
4+
5+
// class CompilerErrors extends CompilerTesting {
6+
// @Test
7+
// def t7185() =
8+
// expectXmlError("""|overloaded method value apply with alternatives:
9+
// | (f: scala.xml.Node => Boolean)scala.xml.NodeSeq <and>
10+
// | (i: Int)scala.xml.Node
11+
// | cannot be applied to ()""".stripMargin,
12+
// """|object Test {
13+
// | <e></e>()
14+
// |}""")
15+
16+
// @Test
17+
// def t1878_typer() =
18+
// expectXmlError("_* may only come last",
19+
// """|object Test extends App {
20+
// | // illegal - bug #1764
21+
// | null match {
22+
// | case <p> { _* } </p> =>
23+
// | }
24+
// |}""")
25+
26+
27+
// @Test
28+
// def t1017() =
29+
// expectXmlErrors(1, "not found: value foo",
30+
// """|object Test {
31+
// | <x><x><x><x><x><x><x><x><x><x><x><x><x><x><x><x><x><x>{ foo }</x></x></x></x></x></x></x></x></x></x></x></x></x></x></x></x></x></x>
32+
// |}""")
33+
34+
// @Test
35+
// def t1011() =
36+
// expectXmlErrors(69, "not found: value entity",
37+
// """|import scala.xml._;
38+
// |
39+
// |abstract class Test {
40+
// | //val entity : String;
41+
// | def primitiveHeader : NodeSeq =
42+
// | Group({
43+
// | <dl><code>{Text(entity)}</code>
44+
// | <code>{Text(entity)}</code>
45+
// | <code>{Text(entity)}</code>
46+
// | <code>{Text(entity)}</code>
47+
// | <code>{Text(entity)}</code>
48+
// | <code>{Text(entity)}</code>
49+
// | <code>{Text(entity)}</code>
50+
// | <code>{Text(entity)}</code>
51+
// | <code>{Text(entity)}</code>
52+
// | <code>{Text(entity)}</code>
53+
// | <code>{Text(entity)}</code>
54+
// | <code>{Text(entity)}</code>
55+
// | <code>{Text(entity)}</code>
56+
// | <code>{Text(entity)}</code>
57+
// | <code>{Text(entity)}</code>
58+
// | <code>{Text(entity)}</code>
59+
// | <code>{Text(entity)}</code>
60+
// | <code>{Text(entity)}</code>
61+
// | <code>{Text(entity)}</code>
62+
// | <code>{Text(entity)}</code>
63+
// | <code>{Text(entity)}</code>
64+
// | <code>{Text(entity)}</code>
65+
// | <code>{Text(entity)}</code>
66+
// | <code>{Text(entity)}</code>
67+
// | <code>{Text(entity)}</code>
68+
// | <code>{Text(entity)}</code>
69+
// | <code>{Text(entity)}</code>
70+
// | <code>{Text(entity)}</code>
71+
// | <code>{Text(entity)}</code>
72+
// | <code>{Text(entity)}</code>
73+
// | <code>{Text(entity)}</code>
74+
// | <code>{Text(entity)}</code>
75+
// | <code>{Text(entity)}</code>
76+
// | <code>{Text(entity)}</code>
77+
// | <code>{Text(entity)}</code>
78+
// | <code>{Text(entity)}</code>
79+
// | <code>{Text(entity)}</code>
80+
// | <code>{Text(entity)}</code>
81+
// | <code>{Text(entity)}</code>
82+
// | <code>{Text(entity)}</code>
83+
// | <code>{Text(entity)}</code>
84+
// | <code>{Text(entity)}</code>
85+
// | <code>{Text(entity)}</code>
86+
// | <code>{Text(entity)}</code>
87+
// | <code>{Text(entity)}</code>
88+
// | <code>{Text(entity)}</code>
89+
// | <code>{Text(entity)}</code>
90+
// | <code>{Text(entity)}</code>
91+
// | <code>{Text(entity)}</code>
92+
// | <code>{Text(entity)}</code>
93+
// | <code>{Text(entity)}</code>
94+
// | <code>{Text(entity)}</code>
95+
// | <code>{Text(entity)}</code>
96+
// | <code>{Text(entity)}</code>
97+
// | <code>{Text(entity)}</code>
98+
// | <code>{Text(entity)}</code>
99+
// | <code>{Text(entity)}</code>
100+
// | <code>{Text(entity)}</code>
101+
// | <code>{Text(entity)}</code>
102+
// | <code>{Text(entity)}</code>
103+
// | <code>{Text(entity)}</code>
104+
// | <code>{Text(entity)}</code>
105+
// | <code>{Text(entity)}</code>
106+
// | <code>{Text(entity)}</code>
107+
// | <code>{Text(entity)}</code>
108+
// | <code>{Text(entity)}</code>
109+
// | <code>{Text(entity)}</code>
110+
// | <code>{Text(entity)}</code>
111+
// | <code>{Text(entity)}</code></dl>
112+
// | } ++ // 3 seconds
113+
// | {}++ // 5 seconds
114+
// | {}++ // 10 seconds
115+
// | {}++ // 20 seconds
116+
// | {}++ // 40 seconds
117+
// | {}++ // 40 seconds
118+
// | {}++ // 40 seconds
119+
// | {}++ // 40 seconds
120+
// | {}++ // 40 seconds
121+
// | {}++ // 40 seconds
122+
// | {}++ // 40 seconds
123+
// | {}++ // 40 seconds
124+
// | {}++ // 40 seconds
125+
// | {}++ // 40 seconds
126+
// | {}++ // 40 seconds
127+
// | {}++ // 40 seconds
128+
// | {}++ // 40 seconds
129+
// | {}++ // 5 seconds
130+
// | {}++ // 10 seconds
131+
// | {}++ // 20 seconds
132+
// | {}++ // 40 seconds
133+
// | {}++ // 40 seconds
134+
// | {}++ // 40 seconds
135+
// | {}++ // 40 seconds
136+
// | {}++ // 40 seconds
137+
// | {}++ // 40 seconds
138+
// | {}++ // 40 seconds
139+
// | {}++ // 40 seconds
140+
// | {}++ // 40 seconds
141+
// | {}++ // 40 seconds
142+
// | {}++ // 40 seconds
143+
// | {}++ // 40 seconds
144+
// | {}++ // 40 seconds
145+
// | {}++ // 5 seconds
146+
// | {}++ // 10 seconds
147+
// | {}++ // 20 seconds
148+
// | {}++ // 40 seconds
149+
// | {}++ // 40 seconds
150+
// | {}++ // 40 seconds
151+
// | {}++ // 40 seconds
152+
// | {}++ // 40 seconds
153+
// | {}++ // 40 seconds
154+
// | {}++ // 40 seconds
155+
// | {}++ // 40 seconds
156+
// | {}++ // 40 seconds
157+
// | {}++ // 40 seconds
158+
// | {}++ // 40 seconds
159+
// | {}++ // 40 seconds
160+
// | {}++ // 40 seconds
161+
// | <hr/>);
162+
// |}""")
163+
// }
164+
165+
// // TODO: factor out somewhere?
166+
// class CompilerTesting {
167+
// // TODO: refine this; for now, just println -- the goal is to ensure we're testing the right version of scala-xml
168+
// // (it should print the same thing as the version in the sbt build)
169+
// // we used to always test the scala-xml jar that the compiler depends on, because it was part of the scala-tool ivy config
170+
// println(s"Testing scala-xml version ${Properties.versionNumberString}.")
171+
172+
// def errorMessages(errorSnippet: String, compileOptions: String = "")(code: String): List[String] = {
173+
// import scala.tools.reflect._
174+
// val m = scala.reflect.runtime.currentMirror
175+
// val tb = m.mkToolBox(options = compileOptions) //: ToolBox[m.universe.type]
176+
// val fe = tb.frontEnd
177+
178+
// try {
179+
// tb.eval(tb.parse(code))
180+
// Nil
181+
// } catch { case _: ToolBoxError =>
182+
// import fe._
183+
// infos.toList collect { case Info(_, msg, ERROR) => msg }
184+
// }
185+
// }
186+
187+
// // note: `code` should have a | margin
188+
// // the import's needed because toolbox compiler does not accumulate imports like the real one (TODO: verify hypothesis)
189+
// def xmlErrorMessages(msg: String, code: String) =
190+
// errorMessages(msg)("import scala.xml.{TopScope => $scope}\n"+ code.stripMargin)
191+
192+
// def expectXmlError(msg: String, code: String) = {
193+
// val errors = xmlErrorMessages(msg, code)
194+
// assert(errors exists (_ contains msg), errors mkString "\n")
195+
// }
196+
197+
// def expectXmlErrors(msgCount: Int, msg: String, code: String) = {
198+
// val errors = xmlErrorMessages(msg, code)
199+
// val errorCount = errors.filter(_ contains msg).length
200+
// assert(errorCount == msgCount, s"$errorCount occurrences of \'$msg\' found -- expected $msgCount in:\n${errors mkString "\n"}")
201+
// }
202+
// }

‎xml/js/src/test/scala/scala/xml/ReuseNodesTest.scala‎

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
package scala.xml
2+
3+
import scala.xml.transform._
4+
import org.junit.Test
5+
import org.junit.Assert.assertTrue
6+
import org.junit.Assert.assertEquals
7+
// import org.junit.experimental.theories.Theories
8+
// import org.junit.experimental.theories.Theory
9+
// import org.junit.experimental.theories.DataPoints
10+
import org.junit.runner.RunWith
11+
/**
12+
* This test verify that after the tranform, the resultant xml node
13+
* uses as many old nodes as possible.
14+
*
15+
* Three transformers class for case -
16+
* One for orginal, one for modified, and one proposed which shows
17+
* all are equivalent when it comes to reusing as many nodes as possible
18+
*/
19+
object ReuseNodesTest {
20+
21+
class OriginalTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
22+
override def transform(ns: Seq[Node]): Seq[Node] = {
23+
val xs = ns.toStream map transform
24+
val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
25+
26+
if (xs2.isEmpty) ns
27+
else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
28+
}
29+
override def transform(n:Node): Seq[Node] = super.transform(n)
30+
}
31+
32+
class ModifiedTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
33+
override def transform(ns: Seq[Node]): Seq[Node] = {
34+
val changed = ns flatMap transform
35+
36+
if (changed.length != ns.length || (changed, ns).zipped.exists(_ != _)) changed
37+
else ns
38+
}
39+
override def transform(n:Node): Seq[Node] = super.transform(n)
40+
}
41+
42+
class AlternateTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
43+
override def transform(ns: Seq[Node]): Seq[Node] = {
44+
val xs = ns.toStream map transform
45+
val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
46+
47+
if (xs2.isEmpty) ns
48+
else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
49+
}
50+
override def transform(n:Node): Seq[Node] = super.transform(n)
51+
}
52+
53+
def rewriteRule = new RewriteRule {
54+
override def transform(n: Node): NodeSeq = n match {
55+
case n if n.label == "change" => Elem(
56+
n.prefix, "changed", n.attributes, n.scope, n.child.isEmpty, n.child : _*)
57+
case _ => n
58+
}
59+
}
60+
61+
// @DataPoints
62+
// def tranformers() = Array(
63+
// new OriginalTranformr(rewriteRule),
64+
// new ModifiedTranformr(rewriteRule),
65+
// new AlternateTranformr(rewriteRule))
66+
}
67+
68+
// @RunWith(classOf[Theories])
69+
// class ReuseNodesTest {
70+
71+
// @Theory
72+
// def transformReferentialEquality(rt:RuleTransformer) = {
73+
// val original = <p><lost/></p>
74+
// val tranformed = rt.transform(original)
75+
// assertTrue(original eq tranformed)
76+
// }
77+
78+
// @Theory
79+
// def transformReferentialEqualityOnly(rt:RuleTransformer) = {
80+
// val original = <changed><change><lost/><a><b><c/></b></a></change><a><b><c/></b></a></changed>
81+
// val transformed = rt.transform(original)
82+
// recursiveAssert(original,transformed)
83+
// }
84+
85+
// def recursiveAssert(original:Seq[Node], transformed:Seq[Node]):Unit = {
86+
// (original.toList,transformed.toList) match {
87+
// case (Nil, Nil) => {}
88+
// case (x::xs,y::ys) => {
89+
// recursiveAssert(x,y)
90+
// recursiveAssert(xs,ys)
91+
// }
92+
// case _ => {}
93+
// }
94+
// }
95+
96+
// def recursiveAssert(original:Node, transformed:Node):Unit = {
97+
// transformed.label match {
98+
// case "changed" => // do nothing expect this node to be changed
99+
// recursiveAssert(original.child,transformed.child)
100+
// case _ => {
101+
// assertTrue(original eq transformed)
102+
// // No need to check for childrens, node being immuatable
103+
// // childs can't be differnt if parents are refertially equal
104+
// }
105+
// }
106+
// }
107+
// }

‎xml/js/src/test/scala/scala/xml/XMLSyntaxTest.scala‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
package scala.xml
2+
3+
import org.junit.Test
4+
import org.junit.Ignore
5+
import org.junit.runner.RunWith
6+
import org.junit.runners.JUnit4
7+
import org.junit.Assert.assertTrue
8+
import org.junit.Assert.assertFalse
9+
import org.junit.Assert.assertEquals
10+
11+
class XMLSyntaxTest {
12+
13+
private def handle[A](x: Node): A = {
14+
x.child(0).asInstanceOf[Atom[A]].data
15+
}
16+
17+
@Test
18+
def test1(): Unit = {
19+
val xNull = <hello>{null}</hello> // these used to be Atom(unit), changed to empty children
20+
assertTrue(xNull.child sameElements Nil)
21+
22+
val x0 = <hello>{}</hello> // these used to be Atom(unit), changed to empty children
23+
val x00 = <hello>{ }</hello> // dto.
24+
val xa = <hello>{ "world" }</hello>
25+
26+
assertTrue(x0.child sameElements Nil)
27+
assertTrue(x00.child sameElements Nil)
28+
assertEquals("world", handle[String](xa))
29+
30+
val xb = <hello>{ 1.5 }</hello>
31+
assertEquals(1.5, handle[Double](xb), 0.0)
32+
33+
val xc = <hello>{ 5 }</hello>
34+
assertEquals(5, handle[Int](xc))
35+
36+
val xd = <hello>{ true }</hello>
37+
assertEquals(true, handle[Boolean](xd))
38+
39+
val xe = <hello>{ 5:Short }</hello>
40+
assertEquals((5:Short), handle[Short](xe))
41+
42+
val xf = <hello>{ val x = 27; x }</hello>
43+
assertEquals(27, handle[Int](xf))
44+
45+
val xg = <hello>{ List(1,2,3,4) }</hello>
46+
assertEquals("<hello>1 2 3 4</hello>", xg.toString)
47+
assertFalse(xg.child.map(_.isInstanceOf[Text]).exists(identity))
48+
49+
val xh = <hello>{ for(x <- List(1,2,3,4) if x % 2 == 0) yield x }</hello>
50+
assertEquals("<hello>2 4</hello>", xh.toString)
51+
assertFalse(xh.child.map(_.isInstanceOf[Text]).exists(identity))
52+
}
53+
54+
/** see SVN r13821 (emir): support for <elem key={x:Option[Seq[Node]]} />,
55+
* so that Options can be used for optional attributes.
56+
*/
57+
@Test
58+
def test2(): Unit = {
59+
val x1: Option[Seq[Node]] = Some(<b>hello</b>)
60+
val n1 = <elem key={x1} />;
61+
assertEquals(x1, n1.attribute("key"))
62+
63+
val x2: Option[Seq[Node]] = None
64+
val n2 = <elem key={x2} />;
65+
assertEquals(x2, n2.attribute("key"))
66+
}
67+
68+
// @Test
69+
// def test3(): Unit = {
70+
// // this demonstrates how to handle entities
71+
// val s = io.Source.fromString("<a>&nbsp;</a>")
72+
// object parser extends xml.parsing.ConstructingParser(s, false /*ignore ws*/) {
73+
// override def replacementText(entityName: String): io.Source = {
74+
// entityName match {
75+
// case "nbsp" => io.Source.fromString("\u0160");
76+
// case _ => super.replacementText(entityName);
77+
// }
78+
// }
79+
// nextch; // !!important, to initialize the parser
80+
// }
81+
// val parsed = parser.element(TopScope) // parse the source as element
82+
// // alternatively, we could call document()
83+
// assertEquals("<a>Š</a>", parsed.toString)
84+
// }
85+
86+
}

0 commit comments

Comments
 (0)