source: trunk/server/www/vendors/simpletest/test/parser_test.php @ 6

Last change on this file since 6 was 6, checked in by sander, 12 years ago

Added SimpleTest? test framework

File size: 22.5 KB
Line 
1<?php
2// $Id: parser_test.php 1608 2007-12-27 09:03:07Z pp11 $
3require_once(dirname(__FILE__) . '/../autorun.php');
4require_once(dirname(__FILE__) . '/../parser.php');
5Mock::generate('SimpleHtmlSaxParser');
6Mock::generate('SimpleSaxListener');
7
8class TestOfParallelRegex extends UnitTestCase {
9   
10    function testNoPatterns() {
11        $regex = &new ParallelRegex(false);
12        $this->assertFalse($regex->match("Hello", $match));
13        $this->assertEqual($match, "");
14    }
15   
16    function testNoSubject() {
17        $regex = &new ParallelRegex(false);
18        $regex->addPattern(".*");
19        $this->assertTrue($regex->match("", $match));
20        $this->assertEqual($match, "");
21    }
22   
23    function testMatchAll() {
24        $regex = &new ParallelRegex(false);
25        $regex->addPattern(".*");
26        $this->assertTrue($regex->match("Hello", $match));
27        $this->assertEqual($match, "Hello");
28    }
29   
30    function testCaseSensitive() {
31        $regex = &new ParallelRegex(true);
32        $regex->addPattern("abc");
33        $this->assertTrue($regex->match("abcdef", $match));
34        $this->assertEqual($match, "abc");
35        $this->assertTrue($regex->match("AAABCabcdef", $match));
36        $this->assertEqual($match, "abc");
37    }
38   
39    function testCaseInsensitive() {
40        $regex = &new ParallelRegex(false);
41        $regex->addPattern("abc");
42        $this->assertTrue($regex->match("abcdef", $match));
43        $this->assertEqual($match, "abc");
44        $this->assertTrue($regex->match("AAABCabcdef", $match));
45        $this->assertEqual($match, "ABC");
46    }
47   
48    function testMatchMultiple() {
49        $regex = &new ParallelRegex(true);
50        $regex->addPattern("abc");
51        $regex->addPattern("ABC");
52        $this->assertTrue($regex->match("abcdef", $match));
53        $this->assertEqual($match, "abc");
54        $this->assertTrue($regex->match("AAABCabcdef", $match));
55        $this->assertEqual($match, "ABC");
56        $this->assertFalse($regex->match("Hello", $match));
57    }
58   
59    function testPatternLabels() {
60        $regex = &new ParallelRegex(false);
61        $regex->addPattern("abc", "letter");
62        $regex->addPattern("123", "number");
63        $this->assertIdentical($regex->match("abcdef", $match), "letter");
64        $this->assertEqual($match, "abc");
65        $this->assertIdentical($regex->match("0123456789", $match), "number");
66        $this->assertEqual($match, "123");
67    }
68}
69
70class TestOfStateStack extends UnitTestCase {
71   
72    function testStartState() {
73        $stack = &new SimpleStateStack("one");
74        $this->assertEqual($stack->getCurrent(), "one");
75    }
76   
77    function testExhaustion() {
78        $stack = &new SimpleStateStack("one");
79        $this->assertFalse($stack->leave());
80    }
81   
82    function testStateMoves() {
83        $stack = &new SimpleStateStack("one");
84        $stack->enter("two");
85        $this->assertEqual($stack->getCurrent(), "two");
86        $stack->enter("three");
87        $this->assertEqual($stack->getCurrent(), "three");
88        $this->assertTrue($stack->leave());
89        $this->assertEqual($stack->getCurrent(), "two");
90        $stack->enter("third");
91        $this->assertEqual($stack->getCurrent(), "third");
92        $this->assertTrue($stack->leave());
93        $this->assertTrue($stack->leave());
94        $this->assertEqual($stack->getCurrent(), "one");
95    }
96}
97
98class TestParser {
99   
100    function accept() {
101    }
102   
103    function a() {
104    }
105   
106    function b() {
107    }
108}
109Mock::generate('TestParser');
110
111class TestOfLexer extends UnitTestCase {
112   
113    function testEmptyPage() {
114        $handler = &new MockTestParser();
115        $handler->expectNever("accept");
116        $handler->setReturnValue("accept", true);
117        $handler->expectNever("accept");
118        $handler->setReturnValue("accept", true);
119        $lexer = &new SimpleLexer($handler);
120        $lexer->addPattern("a+");
121        $this->assertTrue($lexer->parse(""));
122    }
123   
124    function testSinglePattern() {
125        $handler = &new MockTestParser();
126        $handler->expectArgumentsAt(0, "accept", array("aaa", LEXER_MATCHED));
127        $handler->expectArgumentsAt(1, "accept", array("x", LEXER_UNMATCHED));
128        $handler->expectArgumentsAt(2, "accept", array("a", LEXER_MATCHED));
129        $handler->expectArgumentsAt(3, "accept", array("yyy", LEXER_UNMATCHED));
130        $handler->expectArgumentsAt(4, "accept", array("a", LEXER_MATCHED));
131        $handler->expectArgumentsAt(5, "accept", array("x", LEXER_UNMATCHED));
132        $handler->expectArgumentsAt(6, "accept", array("aaa", LEXER_MATCHED));
133        $handler->expectArgumentsAt(7, "accept", array("z", LEXER_UNMATCHED));
134        $handler->expectCallCount("accept", 8);
135        $handler->setReturnValue("accept", true);
136        $lexer = &new SimpleLexer($handler);
137        $lexer->addPattern("a+");
138        $this->assertTrue($lexer->parse("aaaxayyyaxaaaz"));
139    }
140   
141    function testMultiplePattern() {
142        $handler = &new MockTestParser();
143        $target = array("a", "b", "a", "bb", "x", "b", "a", "xxxxxx", "a", "x");
144        for ($i = 0; $i < count($target); $i++) {
145            $handler->expectArgumentsAt($i, "accept", array($target[$i], '*'));
146        }
147        $handler->expectCallCount("accept", count($target));
148        $handler->setReturnValue("accept", true);
149        $lexer = &new SimpleLexer($handler);
150        $lexer->addPattern("a+");
151        $lexer->addPattern("b+");
152        $this->assertTrue($lexer->parse("ababbxbaxxxxxxax"));
153    }
154}
155
156class TestOfLexerModes extends UnitTestCase {
157   
158    function testIsolatedPattern() {
159        $handler = &new MockTestParser();
160        $handler->expectArgumentsAt(0, "a", array("a", LEXER_MATCHED));
161        $handler->expectArgumentsAt(1, "a", array("b", LEXER_UNMATCHED));
162        $handler->expectArgumentsAt(2, "a", array("aa", LEXER_MATCHED));
163        $handler->expectArgumentsAt(3, "a", array("bxb", LEXER_UNMATCHED));
164        $handler->expectArgumentsAt(4, "a", array("aaa", LEXER_MATCHED));
165        $handler->expectArgumentsAt(5, "a", array("x", LEXER_UNMATCHED));
166        $handler->expectArgumentsAt(6, "a", array("aaaa", LEXER_MATCHED));
167        $handler->expectArgumentsAt(7, "a", array("x", LEXER_UNMATCHED));
168        $handler->expectCallCount("a", 8);
169        $handler->setReturnValue("a", true);
170        $lexer = &new SimpleLexer($handler, "a");
171        $lexer->addPattern("a+", "a");
172        $lexer->addPattern("b+", "b");
173        $this->assertTrue($lexer->parse("abaabxbaaaxaaaax"));
174    }
175   
176    function testModeChange() {
177        $handler = &new MockTestParser();
178        $handler->expectArgumentsAt(0, "a", array("a", LEXER_MATCHED));
179        $handler->expectArgumentsAt(1, "a", array("b", LEXER_UNMATCHED));
180        $handler->expectArgumentsAt(2, "a", array("aa", LEXER_MATCHED));
181        $handler->expectArgumentsAt(3, "a", array("b", LEXER_UNMATCHED));
182        $handler->expectArgumentsAt(4, "a", array("aaa", LEXER_MATCHED));
183        $handler->expectArgumentsAt(0, "b", array(":", LEXER_ENTER));
184        $handler->expectArgumentsAt(1, "b", array("a", LEXER_UNMATCHED));
185        $handler->expectArgumentsAt(2, "b", array("b", LEXER_MATCHED));
186        $handler->expectArgumentsAt(3, "b", array("a", LEXER_UNMATCHED));
187        $handler->expectArgumentsAt(4, "b", array("bb", LEXER_MATCHED));
188        $handler->expectArgumentsAt(5, "b", array("a", LEXER_UNMATCHED));
189        $handler->expectArgumentsAt(6, "b", array("bbb", LEXER_MATCHED));
190        $handler->expectArgumentsAt(7, "b", array("a", LEXER_UNMATCHED));
191        $handler->expectCallCount("a", 5);
192        $handler->expectCallCount("b", 8);
193        $handler->setReturnValue("a", true);
194        $handler->setReturnValue("b", true);
195        $lexer = &new SimpleLexer($handler, "a");
196        $lexer->addPattern("a+", "a");
197        $lexer->addEntryPattern(":", "a", "b");
198        $lexer->addPattern("b+", "b");
199        $this->assertTrue($lexer->parse("abaabaaa:ababbabbba"));
200    }
201   
202    function testNesting() {
203        $handler = &new MockTestParser();
204        $handler->setReturnValue("a", true);
205        $handler->setReturnValue("b", true);
206        $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
207        $handler->expectArgumentsAt(1, "a", array("b", LEXER_UNMATCHED));
208        $handler->expectArgumentsAt(2, "a", array("aa", LEXER_MATCHED));
209        $handler->expectArgumentsAt(3, "a", array("b", LEXER_UNMATCHED));
210        $handler->expectArgumentsAt(0, "b", array("(", LEXER_ENTER));
211        $handler->expectArgumentsAt(1, "b", array("bb", LEXER_MATCHED));
212        $handler->expectArgumentsAt(2, "b", array("a", LEXER_UNMATCHED));
213        $handler->expectArgumentsAt(3, "b", array("bb", LEXER_MATCHED));
214        $handler->expectArgumentsAt(4, "b", array(")", LEXER_EXIT));
215        $handler->expectArgumentsAt(4, "a", array("aa", LEXER_MATCHED));
216        $handler->expectArgumentsAt(5, "a", array("b", LEXER_UNMATCHED));
217        $handler->expectCallCount("a", 6);
218        $handler->expectCallCount("b", 5);
219        $lexer = &new SimpleLexer($handler, "a");
220        $lexer->addPattern("a+", "a");
221        $lexer->addEntryPattern("(", "a", "b");
222        $lexer->addPattern("b+", "b");
223        $lexer->addExitPattern(")", "b");
224        $this->assertTrue($lexer->parse("aabaab(bbabb)aab"));
225    }
226   
227    function testSingular() {
228        $handler = &new MockTestParser();
229        $handler->setReturnValue("a", true);
230        $handler->setReturnValue("b", true);
231        $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
232        $handler->expectArgumentsAt(1, "a", array("aa", LEXER_MATCHED));
233        $handler->expectArgumentsAt(2, "a", array("xx", LEXER_UNMATCHED));
234        $handler->expectArgumentsAt(3, "a", array("xx", LEXER_UNMATCHED));
235        $handler->expectArgumentsAt(0, "b", array("b", LEXER_SPECIAL));
236        $handler->expectArgumentsAt(1, "b", array("bbb", LEXER_SPECIAL));
237        $handler->expectCallCount("a", 4);
238        $handler->expectCallCount("b", 2);
239        $lexer = &new SimpleLexer($handler, "a");
240        $lexer->addPattern("a+", "a");
241        $lexer->addSpecialPattern("b+", "a", "b");
242        $this->assertTrue($lexer->parse("aabaaxxbbbxx"));
243    }
244   
245    function testUnwindTooFar() {
246        $handler = &new MockTestParser();
247        $handler->setReturnValue("a", true);
248        $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
249        $handler->expectArgumentsAt(1, "a", array(")", LEXER_EXIT));
250        $handler->expectCallCount("a", 2);
251        $lexer = &new SimpleLexer($handler, "a");
252        $lexer->addPattern("a+", "a");
253        $lexer->addExitPattern(")", "a");
254        $this->assertFalse($lexer->parse("aa)aa"));
255    }
256}
257
258class TestOfLexerHandlers extends UnitTestCase {
259   
260    function testModeMapping() {
261        $handler = &new MockTestParser();
262        $handler->setReturnValue("a", true);
263        $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
264        $handler->expectArgumentsAt(1, "a", array("(", LEXER_ENTER));
265        $handler->expectArgumentsAt(2, "a", array("bb", LEXER_MATCHED));
266        $handler->expectArgumentsAt(3, "a", array("a", LEXER_UNMATCHED));
267        $handler->expectArgumentsAt(4, "a", array("bb", LEXER_MATCHED));
268        $handler->expectArgumentsAt(5, "a", array(")", LEXER_EXIT));
269        $handler->expectArgumentsAt(6, "a", array("b", LEXER_UNMATCHED));
270        $handler->expectCallCount("a", 7);
271        $lexer = &new SimpleLexer($handler, "mode_a");
272        $lexer->addPattern("a+", "mode_a");
273        $lexer->addEntryPattern("(", "mode_a", "mode_b");
274        $lexer->addPattern("b+", "mode_b");
275        $lexer->addExitPattern(")", "mode_b");
276        $lexer->mapHandler("mode_a", "a");
277        $lexer->mapHandler("mode_b", "a");
278        $this->assertTrue($lexer->parse("aa(bbabb)b"));
279    }
280}
281
282class TestOfSimpleHtmlLexer extends UnitTestCase {
283   
284    function &createParser() {
285        $parser = &new MockSimpleHtmlSaxParser();
286        $parser->setReturnValue('acceptStartToken', true);
287        $parser->setReturnValue('acceptEndToken', true);
288        $parser->setReturnValue('acceptAttributeToken', true);
289        $parser->setReturnValue('acceptEntityToken', true);
290        $parser->setReturnValue('acceptTextToken', true);
291        $parser->setReturnValue('ignore', true);
292        return $parser;
293    }
294   
295    function testNoContent() {
296        $parser = &$this->createParser();
297        $parser->expectNever('acceptStartToken');
298        $parser->expectNever('acceptEndToken');
299        $parser->expectNever('acceptAttributeToken');
300        $parser->expectNever('acceptEntityToken');
301        $parser->expectNever('acceptTextToken');
302        $lexer = &new SimpleHtmlLexer($parser);
303        $this->assertTrue($lexer->parse(''));
304    }
305   
306    function testUninteresting() {
307        $parser = &$this->createParser();
308        $parser->expectOnce('acceptTextToken', array('<html></html>', '*'));
309        $lexer = &new SimpleHtmlLexer($parser);
310        $this->assertTrue($lexer->parse('<html></html>'));
311    }
312   
313    function testSkipCss() {
314        $parser = &$this->createParser();
315        $parser->expectNever('acceptTextToken');
316        $parser->expectAtLeastOnce('ignore');
317        $lexer = &new SimpleHtmlLexer($parser);
318        $this->assertTrue($lexer->parse("<style>Lot's of styles</style>"));
319    }
320   
321    function testSkipJavaScript() {
322        $parser = &$this->createParser();
323        $parser->expectNever('acceptTextToken');
324        $parser->expectAtLeastOnce('ignore');
325        $lexer = &new SimpleHtmlLexer($parser);
326        $this->assertTrue($lexer->parse("<SCRIPT>Javascript code {';:^%^%£$'@\"*(}</SCRIPT>"));
327    }
328   
329    function testSkipHtmlComments() {
330        $parser = &$this->createParser();
331        $parser->expectNever('acceptTextToken');
332        $parser->expectAtLeastOnce('ignore');
333        $lexer = &new SimpleHtmlLexer($parser);
334        $this->assertTrue($lexer->parse("<!-- <title>title</title><style>styles</style> -->"));
335    }
336   
337    function testTagWithNoAttributes() {
338        $parser = &$this->createParser();
339        $parser->expectAt(0, 'acceptStartToken', array('<title', '*'));
340        $parser->expectAt(1, 'acceptStartToken', array('>', '*'));
341        $parser->expectCallCount('acceptStartToken', 2);
342        $parser->expectOnce('acceptTextToken', array('Hello', '*'));
343        $parser->expectOnce('acceptEndToken', array('</title>', '*'));
344        $lexer = &new SimpleHtmlLexer($parser);
345        $this->assertTrue($lexer->parse('<title>Hello</title>'));
346    }
347   
348    function testTagWithAttributes() {
349        $parser = &$this->createParser();
350        $parser->expectOnce('acceptTextToken', array('label', '*'));
351        $parser->expectAt(0, 'acceptStartToken', array('<a', '*'));
352        $parser->expectAt(1, 'acceptStartToken', array('href', '*'));
353        $parser->expectAt(2, 'acceptStartToken', array('>', '*'));
354        $parser->expectCallCount('acceptStartToken', 3);
355        $parser->expectAt(0, 'acceptAttributeToken', array('= "', '*'));
356        $parser->expectAt(1, 'acceptAttributeToken', array('here.html', '*'));
357        $parser->expectAt(2, 'acceptAttributeToken', array('"', '*'));
358        $parser->expectCallCount('acceptAttributeToken', 3);
359        $parser->expectOnce('acceptEndToken', array('</a>', '*'));
360        $lexer = &new SimpleHtmlLexer($parser);
361        $this->assertTrue($lexer->parse('<a href = "here.html">label</a>'));
362    }
363}
364
365class TestOfHtmlSaxParser extends UnitTestCase {
366   
367    function &createListener() {
368        $listener = &new MockSimpleSaxListener();
369        $listener->setReturnValue('startElement', true);
370        $listener->setReturnValue('addContent', true);
371        $listener->setReturnValue('endElement', true);
372        return $listener;
373    }
374   
375    function testFramesetTag() {
376        $listener = &$this->createListener();
377        $listener->expectOnce('startElement', array('frameset', array()));
378        $listener->expectOnce('addContent', array('Frames'));
379        $listener->expectOnce('endElement', array('frameset'));
380        $parser = &new SimpleHtmlSaxParser($listener);
381        $this->assertTrue($parser->parse('<frameset>Frames</frameset>'));
382    }
383   
384    function testTagWithUnquotedAttributes() {
385        $listener = &$this->createListener();
386        $listener->expectOnce(
387                'startElement',
388                array('input', array('name' => 'a.b.c', 'value' => 'd')));
389        $parser = &new SimpleHtmlSaxParser($listener);
390        $this->assertTrue($parser->parse('<input name=a.b.c value = d>'));
391    }
392   
393    function testTagInsideContent() {
394        $listener = &$this->createListener();
395        $listener->expectOnce('startElement', array('a', array()));
396        $listener->expectAt(0, 'addContent', array('<html>'));
397        $listener->expectAt(1, 'addContent', array('</html>'));
398        $parser = &new SimpleHtmlSaxParser($listener);
399        $this->assertTrue($parser->parse('<html><a></a></html>'));
400    }
401   
402    function testTagWithInternalContent() {
403        $listener = &$this->createListener();
404        $listener->expectOnce('startElement', array('a', array()));
405        $listener->expectOnce('addContent', array('label'));
406        $listener->expectOnce('endElement', array('a'));
407        $parser = &new SimpleHtmlSaxParser($listener);
408        $this->assertTrue($parser->parse('<a>label</a>'));
409    }
410   
411    function testLinkAddress() {
412        $listener = &$this->createListener();
413        $listener->expectOnce('startElement', array('a', array('href' => 'here.html')));
414        $listener->expectOnce('addContent', array('label'));
415        $listener->expectOnce('endElement', array('a'));
416        $parser = &new SimpleHtmlSaxParser($listener);
417        $this->assertTrue($parser->parse("<a href = 'here.html'>label</a>"));
418    }
419   
420    function testEncodedAttribute() {
421        $listener = &$this->createListener();
422        $listener->expectOnce('startElement', array('a', array('href' => 'here&there.html')));
423        $listener->expectOnce('addContent', array('label'));
424        $listener->expectOnce('endElement', array('a'));
425        $parser = &new SimpleHtmlSaxParser($listener);
426        $this->assertTrue($parser->parse("<a href = 'here&amp;there.html'>label</a>"));
427    }
428   
429    function testTagWithId() {
430        $listener = &$this->createListener();
431        $listener->expectOnce('startElement', array('a', array('id' => '0')));
432        $listener->expectOnce('addContent', array('label'));
433        $listener->expectOnce('endElement', array('a'));
434        $parser = &new SimpleHtmlSaxParser($listener);
435        $this->assertTrue($parser->parse('<a id="0">label</a>'));
436    }
437     
438    function testTagWithEmptyAttributes() {
439        $listener = &$this->createListener();
440        $listener->expectOnce(
441                'startElement',
442                array('option', array('value' => '', 'selected' => '')));
443        $listener->expectOnce('addContent', array('label'));
444        $listener->expectOnce('endElement', array('option'));
445        $parser = &new SimpleHtmlSaxParser($listener);
446        $this->assertTrue($parser->parse('<option value="" selected>label</option>'));
447    }
448   
449    function testComplexTagWithLotsOfCaseVariations() {
450        $listener = &$this->createListener();
451        $listener->expectOnce(
452                'startElement',
453                array('a', array('href' => 'here.html', 'style' => "'cool'")));
454        $listener->expectOnce('addContent', array('label'));
455        $listener->expectOnce('endElement', array('a'));
456        $parser = &new SimpleHtmlSaxParser($listener);
457        $this->assertTrue($parser->parse('<A HREF = \'here.html\' Style="\'cool\'">label</A>'));
458    }
459   
460    function testXhtmlSelfClosingTag() {
461        $listener = &$this->createListener();
462        $listener->expectOnce(
463                'startElement',
464                array('input', array('type' => 'submit', 'name' => 'N', 'value' => 'V')));
465        $parser = &new SimpleHtmlSaxParser($listener);
466        $this->assertTrue($parser->parse('<input type="submit" name="N" value="V" />'));
467    }
468   
469    function testNestedFrameInFrameset() {
470        $listener = &$this->createListener();
471        $listener->expectAt(0, 'startElement', array('frameset', array()));
472        $listener->expectAt(1, 'startElement', array('frame', array('src' => 'frame.html')));
473        $listener->expectCallCount('startElement', 2);
474        $listener->expectOnce('addContent', array('<noframes>Hello</noframes>'));
475        $listener->expectOnce('endElement', array('frameset'));
476        $parser = &new SimpleHtmlSaxParser($listener);
477        $this->assertTrue($parser->parse(
478                '<frameset><frame src="frame.html"><noframes>Hello</noframes></frameset>'));
479    }
480}
481
482class TestOfTextExtraction extends UnitTestCase {
483   
484        function testImageSuppressionWhileKeepingParagraphsAndAltText() {
485        $this->assertEqual(
486                SimpleHtmlSaxParser::normalise('<img src="foo.png" /><p>some text</p><img src="bar.png" alt="bar" />'),
487                'some text bar');
488               
489        }
490
491    function testSpaceNormalisation() {
492        $this->assertEqual(
493                SimpleHtmlSaxParser::normalise("\nOne\tTwo   \nThree\t"),
494                'One Two Three');
495    }
496   
497    function testMultilinesCommentSuppression() {
498        $this->assertEqual(
499                SimpleHtmlSaxParser::normalise('<!--\n Hello \n-->'),
500                '');
501    }
502   
503    function testCommentSuppression() {
504        $this->assertEqual(
505                SimpleHtmlSaxParser::normalise('<!--Hello-->'),
506                '');
507    }
508   
509    function testJavascriptSuppression() {
510        $this->assertEqual(
511                SimpleHtmlSaxParser::normalise('<script attribute="test">\nHello\n</script>'),
512                '');
513        $this->assertEqual(
514                SimpleHtmlSaxParser::normalise('<script attribute="test">Hello</script>'),
515                '');
516        $this->assertEqual(
517                SimpleHtmlSaxParser::normalise('<script>Hello</script>'),
518                '');
519    }
520   
521    function testTagSuppression() {
522        $this->assertEqual(
523                SimpleHtmlSaxParser::normalise('<b>Hello</b>'),
524                'Hello');
525    }
526   
527    function testAdjoiningTagSuppression() {
528        $this->assertEqual(
529                SimpleHtmlSaxParser::normalise('<b>Hello</b><em>Goodbye</em>'),
530                'HelloGoodbye');
531    }
532   
533    function testExtractImageAltTextWithDifferentQuotes() {
534        $this->assertEqual(
535                SimpleHtmlSaxParser::normalise('<img alt="One"><img alt=\'Two\'><img alt=Three>'),
536                'One Two Three');
537    }
538   
539    function testExtractImageAltTextMultipleTimes() {
540        $this->assertEqual(
541                SimpleHtmlSaxParser::normalise('<img alt="One"><img alt="Two"><img alt="Three">'),
542                'One Two Three');
543    }
544   
545    function testHtmlEntityTranslation() {
546        $this->assertEqual(
547                SimpleHtmlSaxParser::normalise('&lt;&gt;&quot;&amp;&#039;'),
548                '<>"&\'');
549    }
550}
551?>
Note: See TracBrowser for help on using the repository browser.