Andreas Hocevar
593 lines
19 KiB
JavaScript
593 lines
19 KiB
JavaScript
// Copyright 2007 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
goog.provide('goog.dom.patternTest');
|
|
goog.setTestOnly('goog.dom.patternTest');
|
|
|
|
goog.require('goog.dom');
|
|
goog.require('goog.dom.NodeType');
|
|
goog.require('goog.dom.TagWalkType');
|
|
goog.require('goog.dom.pattern.AllChildren');
|
|
goog.require('goog.dom.pattern.ChildMatches');
|
|
goog.require('goog.dom.pattern.EndTag');
|
|
goog.require('goog.dom.pattern.FullTag');
|
|
goog.require('goog.dom.pattern.MatchType');
|
|
goog.require('goog.dom.pattern.NodeType');
|
|
goog.require('goog.dom.pattern.Repeat');
|
|
goog.require('goog.dom.pattern.Sequence');
|
|
goog.require('goog.dom.pattern.StartTag');
|
|
goog.require('goog.dom.pattern.Text');
|
|
goog.require('goog.testing.jsunit');
|
|
|
|
// TODO(robbyw): write a test that checks if backtracking works in Sequence
|
|
|
|
function testStartTag() {
|
|
var pattern = new goog.dom.pattern.StartTag('DIV');
|
|
assertEquals(
|
|
'StartTag(div) should match div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(div) should not match span',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(div) should not match /div',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testStartTagCase() {
|
|
var pattern = new goog.dom.pattern.StartTag('diV');
|
|
assertEquals(
|
|
'StartTag(diV) should match div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(diV) should not match span',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testStartTagRegex() {
|
|
var pattern = new goog.dom.pattern.StartTag(/D/);
|
|
assertEquals(
|
|
'StartTag(/D/) should match div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(/D/) should not match span',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(/D/) should not match /div',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testStartTagAttributes() {
|
|
var pattern = new goog.dom.pattern.StartTag('DIV', {id: 'div1'});
|
|
assertEquals(
|
|
'StartTag(div,id:div1) should match div1',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals('StartTag(div,id:div2) should not match div1',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div2'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testStartTagStyle() {
|
|
var pattern = new goog.dom.pattern.StartTag('SPAN', null, {color: 'red'});
|
|
assertEquals(
|
|
'StartTag(span,null,color:red) should match span1',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(span,null,color:blue) should not match span1',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span2'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testStartTagAttributeRegex() {
|
|
var pattern = new goog.dom.pattern.StartTag('SPAN', {id: /span\d/});
|
|
assertEquals(
|
|
'StartTag(span,id:/span\\d/) should match span1',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'StartTag(span,id:/span\\d/) should match span2',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testEndTag() {
|
|
var pattern = new goog.dom.pattern.EndTag('DIV');
|
|
assertEquals(
|
|
'EndTag should match div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testEndTagRegex() {
|
|
var pattern = new goog.dom.pattern.EndTag(/D/);
|
|
assertEquals(
|
|
'EndTag(/D/) should match /div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'EndTag(/D/) should not match /span',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'EndTag(/D/) should not match div',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testChildMatches() {
|
|
var pattern = new goog.dom.pattern.ChildMatches(
|
|
new goog.dom.pattern.StartTag('DIV'), 2);
|
|
|
|
assertEquals(
|
|
'ChildMatches should match div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'ChildMatches should match /div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'ChildMatches should match div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div2'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'ChildMatches should match /div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div2'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'ChildMatches should finish match at /body',
|
|
goog.dom.pattern.MatchType.BACKTRACK_MATCH,
|
|
pattern.matchToken(
|
|
document.body,
|
|
goog.dom.TagWalkType.END_TAG));
|
|
|
|
assertEquals(
|
|
'ChildMatches should match div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div2'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'ChildMatches should match /div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div2'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'ChildMatches should fail to match at /body: not enough child matches',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
document.body,
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testFullTag() {
|
|
var pattern = new goog.dom.pattern.FullTag('DIV');
|
|
assertEquals(
|
|
'FullTag(div) should match div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'FullTag(div) should match /div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
|
|
assertEquals(
|
|
'FullTag(div) should start match at div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'FullTag(div) should continue to match span',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'FullTag(div) should continue to match /span',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'FullTag(div) should finish match at /div',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testAllChildren() {
|
|
var pattern = new goog.dom.pattern.AllChildren();
|
|
assertEquals(
|
|
'AllChildren(div) should match div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'AllChildren(div) should match /div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'AllChildren(div) should match at /body',
|
|
goog.dom.pattern.MatchType.BACKTRACK_MATCH,
|
|
pattern.matchToken(
|
|
document.body,
|
|
goog.dom.TagWalkType.END_TAG));
|
|
|
|
assertEquals(
|
|
'AllChildren(div) should start match at div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'AllChildren(div) should continue to match span',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'AllChildren(div) should continue to match /span',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'AllChildren(div) should continue to match at /div',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'AllChildren(div) should finish match at /body',
|
|
goog.dom.pattern.MatchType.BACKTRACK_MATCH,
|
|
pattern.matchToken(
|
|
document.body,
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testText() {
|
|
var pattern = new goog.dom.pattern.Text('Text');
|
|
assertEquals(
|
|
'Text should match div3/text()',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div3').firstChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
assertEquals(
|
|
'Text should not match div4/text()',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div4').firstChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
assertEquals(
|
|
'Text should not match div3',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div3'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
|
|
}
|
|
|
|
function testTextRegex() {
|
|
var pattern = new goog.dom.pattern.Text(/Text/);
|
|
assertEquals(
|
|
'Text(regex) should match div3/text()',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div3').firstChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
assertEquals(
|
|
'Text(regex) should match div4/text()',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div4').firstChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
}
|
|
|
|
function testNodeType() {
|
|
var pattern = new goog.dom.pattern.NodeType(goog.dom.NodeType.COMMENT);
|
|
assertEquals('Comment matcher should match a comment',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('nodeTypes').firstChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
assertEquals('Comment matcher should not match a text node',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('nodeTypes').lastChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
}
|
|
|
|
function testSequence() {
|
|
var pattern = new goog.dom.pattern.Sequence([
|
|
new goog.dom.pattern.StartTag('DIV'),
|
|
new goog.dom.pattern.StartTag('SPAN'),
|
|
new goog.dom.pattern.EndTag('SPAN'),
|
|
new goog.dom.pattern.EndTag('DIV')]);
|
|
|
|
assertEquals(
|
|
'Sequence[0] should match div1',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[1] should match span1',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[2] should match /span1',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'Sequence[3] should match /div1',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
|
|
assertEquals(
|
|
'Sequence[0] should match div1 again',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[1] should match span1 again',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[2] should match /span1 again',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'Sequence[3] should match /div1 again',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
|
|
assertEquals(
|
|
'Sequence[0] should match div1',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[1] should not match div1',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
|
|
assertEquals(
|
|
'Sequence[0] should match div1 after failure',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[1] should match span1 after failure',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[2] should match /span1 after failure',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('span1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
assertEquals(
|
|
'Sequence[3] should match /div1 after failure',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('div1'),
|
|
goog.dom.TagWalkType.END_TAG));
|
|
}
|
|
|
|
function testRepeat() {
|
|
var pattern = new goog.dom.pattern.Repeat(
|
|
new goog.dom.pattern.StartTag('B'));
|
|
|
|
// Note: this test does not mimic an actual matcher because it is only
|
|
// passing the START_TAG events.
|
|
|
|
assertEquals(
|
|
'Repeat[B] should match b1',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('b1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B] should match b2',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('b2'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B] should backtrack match i1',
|
|
goog.dom.pattern.MatchType.BACKTRACK_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('i1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B] should have match count of 2',
|
|
2,
|
|
pattern.count);
|
|
|
|
assertEquals(
|
|
'Repeat[B] should backtrack match i1 even with no b matches',
|
|
goog.dom.pattern.MatchType.BACKTRACK_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('i1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B] should have match count of 0',
|
|
0,
|
|
pattern.count);
|
|
}
|
|
|
|
function testRepeatWithMinimum() {
|
|
var pattern = new goog.dom.pattern.Repeat(
|
|
new goog.dom.pattern.StartTag('B'), 1);
|
|
|
|
// Note: this test does not mimic an actual matcher because it is only
|
|
// passing the START_TAG events.
|
|
|
|
assertEquals(
|
|
'Repeat[B,1] should match b1',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('b1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B,1] should match b2',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('b2'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B,1] should backtrack match i1',
|
|
goog.dom.pattern.MatchType.BACKTRACK_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('i1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Repeat[B,1] should have match count of 2',
|
|
2,
|
|
pattern.count);
|
|
|
|
assertEquals(
|
|
'Repeat[B,1] should not match i1',
|
|
goog.dom.pattern.MatchType.NO_MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('i1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testRepeatWithMaximum() {
|
|
var pattern = new goog.dom.pattern.Repeat(
|
|
new goog.dom.pattern.StartTag('B'), 1, 1);
|
|
|
|
// Note: this test does not mimic an actual matcher because it is only
|
|
// passing the START_TAG events.
|
|
|
|
assertEquals(
|
|
'Repeat[B,1] should match b1',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(
|
|
goog.dom.getElement('b1'),
|
|
goog.dom.TagWalkType.START_TAG));
|
|
}
|
|
|
|
function testSequenceBacktrack() {
|
|
var pattern = new goog.dom.pattern.Sequence([
|
|
new goog.dom.pattern.Repeat(new goog.dom.pattern.StartTag('SPAN')),
|
|
new goog.dom.pattern.Text('X')]);
|
|
|
|
var root = goog.dom.getElement('span3');
|
|
assertEquals(
|
|
'Sequence[Repeat[SPAN],"X"] should match span3',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(root, goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[Repeat[SPAN],"X"] should match span3.firstChild',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(root.firstChild,
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[Repeat[SPAN],"X"] should match span3.firstChild.firstChild',
|
|
goog.dom.pattern.MatchType.MATCHING,
|
|
pattern.matchToken(root.firstChild.firstChild,
|
|
goog.dom.TagWalkType.START_TAG));
|
|
assertEquals(
|
|
'Sequence[Repeat[SPAN],"X"] should finish match text node',
|
|
goog.dom.pattern.MatchType.MATCH,
|
|
pattern.matchToken(root.firstChild.firstChild.firstChild,
|
|
goog.dom.TagWalkType.OTHER));
|
|
}
|