| // 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)); |
| } |
