Debian Codegraph @

closure-library/closure/goog/dom/pattern/pattern_test.js

raw
1 // Copyright 2007 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.dom.patternTest');
16 goog.setTestOnly('goog.dom.patternTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.NodeType');
20 goog.require('goog.dom.TagWalkType');
21 goog.require('goog.dom.pattern.AllChildren');
22 goog.require('goog.dom.pattern.ChildMatches');
23 goog.require('goog.dom.pattern.EndTag');
24 goog.require('goog.dom.pattern.FullTag');
25 goog.require('goog.dom.pattern.MatchType');
26 goog.require('goog.dom.pattern.NodeType');
27 goog.require('goog.dom.pattern.Repeat');
28 goog.require('goog.dom.pattern.Sequence');
29 goog.require('goog.dom.pattern.StartTag');
30 goog.require('goog.dom.pattern.Text');
31 goog.require('goog.testing.jsunit');
32
33 // TODO(robbyw): write a test that checks if backtracking works in Sequence
34
35 function testStartTag() {
36 var pattern = new goog.dom.pattern.StartTag('DIV');
37 assertEquals(
38 'StartTag(div) should match div', goog.dom.pattern.MatchType.MATCH,
39 pattern.matchToken(
40 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
41 assertEquals(
42 'StartTag(div) should not match span',
43 goog.dom.pattern.MatchType.NO_MATCH,
44 pattern.matchToken(
45 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
46 assertEquals(
47 'StartTag(div) should not match /div',
48 goog.dom.pattern.MatchType.NO_MATCH,
49 pattern.matchToken(
50 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
51 }
52
53 function testStartTagCase() {
54 var pattern = new goog.dom.pattern.StartTag('diV');
55 assertEquals(
56 'StartTag(diV) should match div', goog.dom.pattern.MatchType.MATCH,
57 pattern.matchToken(
58 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
59 assertEquals(
60 'StartTag(diV) should not match span',
61 goog.dom.pattern.MatchType.NO_MATCH,
62 pattern.matchToken(
63 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
64 }
65
66 function testStartTagRegex() {
67 var pattern = new goog.dom.pattern.StartTag(/D/);
68 assertEquals(
69 'StartTag(/D/) should match div', goog.dom.pattern.MatchType.MATCH,
70 pattern.matchToken(
71 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
72 assertEquals(
73 'StartTag(/D/) should not match span',
74 goog.dom.pattern.MatchType.NO_MATCH,
75 pattern.matchToken(
76 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
77 assertEquals(
78 'StartTag(/D/) should not match /div',
79 goog.dom.pattern.MatchType.NO_MATCH,
80 pattern.matchToken(
81 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
82 }
83
84 function testStartTagAttributes() {
85 var pattern = new goog.dom.pattern.StartTag('DIV', {id: 'div1'});
86 assertEquals(
87 'StartTag(div,id:div1) should match div1',
88 goog.dom.pattern.MatchType.MATCH,
89 pattern.matchToken(
90 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
91 assertEquals(
92 'StartTag(div,id:div2) should not match div1',
93 goog.dom.pattern.MatchType.NO_MATCH,
94 pattern.matchToken(
95 goog.dom.getElement('div2'), goog.dom.TagWalkType.START_TAG));
96 }
97
98 function testStartTagStyle() {
99 var pattern = new goog.dom.pattern.StartTag('SPAN', null, {color: 'red'});
100 assertEquals(
101 'StartTag(span,null,color:red) should match span1',
102 goog.dom.pattern.MatchType.MATCH,
103 pattern.matchToken(
104 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
105 assertEquals(
106 'StartTag(span,null,color:blue) should not match span1',
107 goog.dom.pattern.MatchType.NO_MATCH,
108 pattern.matchToken(
109 goog.dom.getElement('span2'), goog.dom.TagWalkType.START_TAG));
110 }
111
112 function testStartTagAttributeRegex() {
113 var pattern = new goog.dom.pattern.StartTag('SPAN', {id: /span\d/});
114 assertEquals(
115 'StartTag(span,id:/span\\d/) should match span1',
116 goog.dom.pattern.MatchType.MATCH,
117 pattern.matchToken(
118 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
119 assertEquals(
120 'StartTag(span,id:/span\\d/) should match span2',
121 goog.dom.pattern.MatchType.MATCH,
122 pattern.matchToken(
123 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
124 }
125
126 function testEndTag() {
127 var pattern = new goog.dom.pattern.EndTag('DIV');
128 assertEquals(
129 'EndTag should match div', goog.dom.pattern.MatchType.MATCH,
130 pattern.matchToken(
131 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
132 }
133
134 function testEndTagRegex() {
135 var pattern = new goog.dom.pattern.EndTag(/D/);
136 assertEquals(
137 'EndTag(/D/) should match /div', goog.dom.pattern.MatchType.MATCH,
138 pattern.matchToken(
139 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
140 assertEquals(
141 'EndTag(/D/) should not match /span', goog.dom.pattern.MatchType.NO_MATCH,
142 pattern.matchToken(
143 goog.dom.getElement('span1'), goog.dom.TagWalkType.END_TAG));
144 assertEquals(
145 'EndTag(/D/) should not match div', goog.dom.pattern.MatchType.NO_MATCH,
146 pattern.matchToken(
147 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
148 }
149
150 function testChildMatches() {
151 var pattern = new goog.dom.pattern.ChildMatches(
152 new goog.dom.pattern.StartTag('DIV'), 2);
153
154 assertEquals(
155 'ChildMatches should match div', goog.dom.pattern.MatchType.MATCHING,
156 pattern.matchToken(
157 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
158 assertEquals(
159 'ChildMatches should match /div', goog.dom.pattern.MatchType.MATCHING,
160 pattern.matchToken(
161 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
162 assertEquals(
163 'ChildMatches should match div', goog.dom.pattern.MatchType.MATCHING,
164 pattern.matchToken(
165 goog.dom.getElement('div2'), goog.dom.TagWalkType.START_TAG));
166 assertEquals(
167 'ChildMatches should match /div', goog.dom.pattern.MatchType.MATCHING,
168 pattern.matchToken(
169 goog.dom.getElement('div2'), goog.dom.TagWalkType.END_TAG));
170 assertEquals(
171 'ChildMatches should finish match at /body',
172 goog.dom.pattern.MatchType.BACKTRACK_MATCH,
173 pattern.matchToken(document.body, goog.dom.TagWalkType.END_TAG));
174
175 assertEquals(
176 'ChildMatches should match div', goog.dom.pattern.MatchType.MATCHING,
177 pattern.matchToken(
178 goog.dom.getElement('div2'), goog.dom.TagWalkType.START_TAG));
179 assertEquals(
180 'ChildMatches should match /div', goog.dom.pattern.MatchType.MATCHING,
181 pattern.matchToken(
182 goog.dom.getElement('div2'), goog.dom.TagWalkType.END_TAG));
183 assertEquals(
184 'ChildMatches should fail to match at /body: not enough child matches',
185 goog.dom.pattern.MatchType.NO_MATCH,
186 pattern.matchToken(document.body, goog.dom.TagWalkType.END_TAG));
187 }
188
189 function testFullTag() {
190 var pattern = new goog.dom.pattern.FullTag('DIV');
191 assertEquals(
192 'FullTag(div) should match div', goog.dom.pattern.MatchType.MATCHING,
193 pattern.matchToken(
194 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
195 assertEquals(
196 'FullTag(div) should match /div', goog.dom.pattern.MatchType.MATCH,
197 pattern.matchToken(
198 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
199
200 assertEquals(
201 'FullTag(div) should start match at div',
202 goog.dom.pattern.MatchType.MATCHING,
203 pattern.matchToken(
204 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
205 assertEquals(
206 'FullTag(div) should continue to match span',
207 goog.dom.pattern.MatchType.MATCHING,
208 pattern.matchToken(
209 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
210 assertEquals(
211 'FullTag(div) should continue to match /span',
212 goog.dom.pattern.MatchType.MATCHING,
213 pattern.matchToken(
214 goog.dom.getElement('span1'), goog.dom.TagWalkType.END_TAG));
215 assertEquals(
216 'FullTag(div) should finish match at /div',
217 goog.dom.pattern.MatchType.MATCH,
218 pattern.matchToken(
219 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
220 }
221
222 function testAllChildren() {
223 var pattern = new goog.dom.pattern.AllChildren();
224 assertEquals(
225 'AllChildren(div) should match div', goog.dom.pattern.MatchType.MATCHING,
226 pattern.matchToken(
227 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
228 assertEquals(
229 'AllChildren(div) should match /div', goog.dom.pattern.MatchType.MATCHING,
230 pattern.matchToken(
231 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
232 assertEquals(
233 'AllChildren(div) should match at /body',
234 goog.dom.pattern.MatchType.BACKTRACK_MATCH,
235 pattern.matchToken(document.body, goog.dom.TagWalkType.END_TAG));
236
237 assertEquals(
238 'AllChildren(div) should start match at div',
239 goog.dom.pattern.MatchType.MATCHING,
240 pattern.matchToken(
241 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
242 assertEquals(
243 'AllChildren(div) should continue to match span',
244 goog.dom.pattern.MatchType.MATCHING,
245 pattern.matchToken(
246 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
247 assertEquals(
248 'AllChildren(div) should continue to match /span',
249 goog.dom.pattern.MatchType.MATCHING,
250 pattern.matchToken(
251 goog.dom.getElement('span1'), goog.dom.TagWalkType.END_TAG));
252 assertEquals(
253 'AllChildren(div) should continue to match at /div',
254 goog.dom.pattern.MatchType.MATCHING,
255 pattern.matchToken(
256 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
257 assertEquals(
258 'AllChildren(div) should finish match at /body',
259 goog.dom.pattern.MatchType.BACKTRACK_MATCH,
260 pattern.matchToken(document.body, goog.dom.TagWalkType.END_TAG));
261 }
262
263 function testText() {
264 var pattern = new goog.dom.pattern.Text('Text');
265 assertEquals(
266 'Text should match div3/text()', goog.dom.pattern.MatchType.MATCH,
267 pattern.matchToken(
268 goog.dom.getElement('div3').firstChild, goog.dom.TagWalkType.OTHER));
269 assertEquals(
270 'Text should not match div4/text()', goog.dom.pattern.MatchType.NO_MATCH,
271 pattern.matchToken(
272 goog.dom.getElement('div4').firstChild, goog.dom.TagWalkType.OTHER));
273 assertEquals(
274 'Text should not match div3', goog.dom.pattern.MatchType.NO_MATCH,
275 pattern.matchToken(
276 goog.dom.getElement('div3'), goog.dom.TagWalkType.START_TAG));
277 }
278
279 function testTextRegex() {
280 var pattern = new goog.dom.pattern.Text(/Text/);
281 assertEquals(
282 'Text(regex) should match div3/text()', goog.dom.pattern.MatchType.MATCH,
283 pattern.matchToken(
284 goog.dom.getElement('div3').firstChild, goog.dom.TagWalkType.OTHER));
285 assertEquals(
286 'Text(regex) should match div4/text()', goog.dom.pattern.MatchType.MATCH,
287 pattern.matchToken(
288 goog.dom.getElement('div4').firstChild, goog.dom.TagWalkType.OTHER));
289 }
290
291 function testNodeType() {
292 var pattern = new goog.dom.pattern.NodeType(goog.dom.NodeType.COMMENT);
293 assertEquals(
294 'Comment matcher should match a comment',
295 goog.dom.pattern.MatchType.MATCH,
296 pattern.matchToken(
297 goog.dom.getElement('nodeTypes').firstChild,
298 goog.dom.TagWalkType.OTHER));
299 assertEquals(
300 'Comment matcher should not match a text node',
301 goog.dom.pattern.MatchType.NO_MATCH,
302 pattern.matchToken(
303 goog.dom.getElement('nodeTypes').lastChild,
304 goog.dom.TagWalkType.OTHER));
305 }
306
307 function testSequence() {
308 var pattern = new goog.dom.pattern.Sequence([
309 new goog.dom.pattern.StartTag('DIV'), new goog.dom.pattern.StartTag('SPAN'),
310 new goog.dom.pattern.EndTag('SPAN'), new goog.dom.pattern.EndTag('DIV')
311 ]);
312
313 assertEquals(
314 'Sequence[0] should match div1', goog.dom.pattern.MatchType.MATCHING,
315 pattern.matchToken(
316 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
317 assertEquals(
318 'Sequence[1] should match span1', goog.dom.pattern.MatchType.MATCHING,
319 pattern.matchToken(
320 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
321 assertEquals(
322 'Sequence[2] should match /span1', goog.dom.pattern.MatchType.MATCHING,
323 pattern.matchToken(
324 goog.dom.getElement('span1'), goog.dom.TagWalkType.END_TAG));
325 assertEquals(
326 'Sequence[3] should match /div1', goog.dom.pattern.MatchType.MATCH,
327 pattern.matchToken(
328 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
329
330 assertEquals(
331 'Sequence[0] should match div1 again',
332 goog.dom.pattern.MatchType.MATCHING,
333 pattern.matchToken(
334 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
335 assertEquals(
336 'Sequence[1] should match span1 again',
337 goog.dom.pattern.MatchType.MATCHING,
338 pattern.matchToken(
339 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
340 assertEquals(
341 'Sequence[2] should match /span1 again',
342 goog.dom.pattern.MatchType.MATCHING,
343 pattern.matchToken(
344 goog.dom.getElement('span1'), goog.dom.TagWalkType.END_TAG));
345 assertEquals(
346 'Sequence[3] should match /div1 again', goog.dom.pattern.MatchType.MATCH,
347 pattern.matchToken(
348 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
349
350 assertEquals(
351 'Sequence[0] should match div1', goog.dom.pattern.MatchType.MATCHING,
352 pattern.matchToken(
353 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
354 assertEquals(
355 'Sequence[1] should not match div1', goog.dom.pattern.MatchType.NO_MATCH,
356 pattern.matchToken(
357 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
358
359 assertEquals(
360 'Sequence[0] should match div1 after failure',
361 goog.dom.pattern.MatchType.MATCHING,
362 pattern.matchToken(
363 goog.dom.getElement('div1'), goog.dom.TagWalkType.START_TAG));
364 assertEquals(
365 'Sequence[1] should match span1 after failure',
366 goog.dom.pattern.MatchType.MATCHING,
367 pattern.matchToken(
368 goog.dom.getElement('span1'), goog.dom.TagWalkType.START_TAG));
369 assertEquals(
370 'Sequence[2] should match /span1 after failure',
371 goog.dom.pattern.MatchType.MATCHING,
372 pattern.matchToken(
373 goog.dom.getElement('span1'), goog.dom.TagWalkType.END_TAG));
374 assertEquals(
375 'Sequence[3] should match /div1 after failure',
376 goog.dom.pattern.MatchType.MATCH,
377 pattern.matchToken(
378 goog.dom.getElement('div1'), goog.dom.TagWalkType.END_TAG));
379 }
380
381 function testRepeat() {
382 var pattern = new goog.dom.pattern.Repeat(new goog.dom.pattern.StartTag('B'));
383
384 // Note: this test does not mimic an actual matcher because it is only
385 // passing the START_TAG events.
386
387 assertEquals(
388 'Repeat[B] should match b1', goog.dom.pattern.MatchType.MATCHING,
389 pattern.matchToken(
390 goog.dom.getElement('b1'), goog.dom.TagWalkType.START_TAG));
391 assertEquals(
392 'Repeat[B] should match b2', goog.dom.pattern.MatchType.MATCHING,
393 pattern.matchToken(
394 goog.dom.getElement('b2'), goog.dom.TagWalkType.START_TAG));
395 assertEquals(
396 'Repeat[B] should backtrack match i1',
397 goog.dom.pattern.MatchType.BACKTRACK_MATCH,
398 pattern.matchToken(
399 goog.dom.getElement('i1'), goog.dom.TagWalkType.START_TAG));
400 assertEquals('Repeat[B] should have match count of 2', 2, pattern.count);
401
402 assertEquals(
403 'Repeat[B] should backtrack match i1 even with no b matches',
404 goog.dom.pattern.MatchType.BACKTRACK_MATCH,
405 pattern.matchToken(
406 goog.dom.getElement('i1'), goog.dom.TagWalkType.START_TAG));
407 assertEquals('Repeat[B] should have match count of 0', 0, pattern.count);
408 }
409
410 function testRepeatWithMinimum() {
411 var pattern =
412 new goog.dom.pattern.Repeat(new goog.dom.pattern.StartTag('B'), 1);
413
414 // Note: this test does not mimic an actual matcher because it is only
415 // passing the START_TAG events.
416
417 assertEquals(
418 'Repeat[B,1] should match b1', goog.dom.pattern.MatchType.MATCHING,
419 pattern.matchToken(
420 goog.dom.getElement('b1'), goog.dom.TagWalkType.START_TAG));
421 assertEquals(
422 'Repeat[B,1] should match b2', goog.dom.pattern.MatchType.MATCHING,
423 pattern.matchToken(
424 goog.dom.getElement('b2'), goog.dom.TagWalkType.START_TAG));
425 assertEquals(
426 'Repeat[B,1] should backtrack match i1',
427 goog.dom.pattern.MatchType.BACKTRACK_MATCH,
428 pattern.matchToken(
429 goog.dom.getElement('i1'), goog.dom.TagWalkType.START_TAG));
430 assertEquals('Repeat[B,1] should have match count of 2', 2, pattern.count);
431
432 assertEquals(
433 'Repeat[B,1] should not match i1', goog.dom.pattern.MatchType.NO_MATCH,
434 pattern.matchToken(
435 goog.dom.getElement('i1'), goog.dom.TagWalkType.START_TAG));
436 }
437
438 function testRepeatWithMaximum() {
439 var pattern =
440 new goog.dom.pattern.Repeat(new goog.dom.pattern.StartTag('B'), 1, 1);
441
442 // Note: this test does not mimic an actual matcher because it is only
443 // passing the START_TAG events.
444
445 assertEquals(
446 'Repeat[B,1] should match b1', goog.dom.pattern.MatchType.MATCH,
447 pattern.matchToken(
448 goog.dom.getElement('b1'), goog.dom.TagWalkType.START_TAG));
449 }
450
451 function testSequenceBacktrack() {
452 var pattern = new goog.dom.pattern.Sequence([
453 new goog.dom.pattern.Repeat(new goog.dom.pattern.StartTag('SPAN')),
454 new goog.dom.pattern.Text('X')
455 ]);
456
457 var root = goog.dom.getElement('span3');
458 assertEquals(
459 'Sequence[Repeat[SPAN],"X"] should match span3',
460 goog.dom.pattern.MatchType.MATCHING,
461 pattern.matchToken(root, goog.dom.TagWalkType.START_TAG));
462 assertEquals(
463 'Sequence[Repeat[SPAN],"X"] should match span3.firstChild',
464 goog.dom.pattern.MatchType.MATCHING,
465 pattern.matchToken(root.firstChild, goog.dom.TagWalkType.START_TAG));
466 assertEquals(
467 'Sequence[Repeat[SPAN],"X"] should match span3.firstChild.firstChild',
468 goog.dom.pattern.MatchType.MATCHING,
469 pattern.matchToken(
470 root.firstChild.firstChild, goog.dom.TagWalkType.START_TAG));
471 assertEquals(
472 'Sequence[Repeat[SPAN],"X"] should finish match text node',
473 goog.dom.pattern.MatchType.MATCH,
474 pattern.matchToken(
475 root.firstChild.firstChild.firstChild, goog.dom.TagWalkType.OTHER));
476 }