Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 7ffd49a

Browse files
Dupliate jvm/test to js/test, commenting unlinkable parts
1 parent 4bd890e commit 7ffd49a

File tree

7 files changed

+1540
-0
lines changed

7 files changed

+1540
-0
lines changed
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+
// }
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+
// }
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)

AltStyle によって変換されたページ (->オリジナル) /