source: trunk/server/www/vendors/simpletest/test/tag_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: 20.9 KB
Line 
1<?php
2// $Id: tag_test.php 1509 2007-05-08 22:11:49Z lastcraft $
3require_once(dirname(__FILE__) . '/../autorun.php');
4require_once(dirname(__FILE__) . '/../tag.php');
5require_once(dirname(__FILE__) . '/../encoding.php');
6Mock::generate('SimpleMultipartEncoding');
7
8class TestOfTag extends UnitTestCase {
9   
10    function testStartValuesWithoutAdditionalContent() {
11        $tag = new SimpleTitleTag(array('a' => '1', 'b' => ''));
12        $this->assertEqual($tag->getTagName(), 'title');
13        $this->assertIdentical($tag->getAttribute('a'), '1');
14        $this->assertIdentical($tag->getAttribute('b'), '');
15        $this->assertIdentical($tag->getAttribute('c'), false);
16        $this->assertIdentical($tag->getContent(), '');
17    }
18   
19    function testTitleContent() {
20        $tag = &new SimpleTitleTag(array());
21        $this->assertTrue($tag->expectEndTag());
22        $tag->addContent('Hello');
23        $tag->addContent('World');
24        $this->assertEqual($tag->getText(), 'HelloWorld');
25    }
26   
27    function testMessyTitleContent() {
28        $tag = &new SimpleTitleTag(array());
29        $this->assertTrue($tag->expectEndTag());
30        $tag->addContent('<b>Hello</b>');
31        $tag->addContent('<em>World</em>');
32        $this->assertEqual($tag->getText(), 'HelloWorld');
33    }
34   
35    function testTagWithNoEnd() {
36        $tag = &new SimpleTextTag(array());
37        $this->assertFalse($tag->expectEndTag());
38    }
39   
40    function testAnchorHref() {
41        $tag = &new SimpleAnchorTag(array('href' => 'http://here/'));
42        $this->assertEqual($tag->getHref(), 'http://here/');
43       
44        $tag = &new SimpleAnchorTag(array('href' => ''));
45        $this->assertIdentical($tag->getAttribute('href'), '');
46        $this->assertIdentical($tag->getHref(), '');
47       
48        $tag = &new SimpleAnchorTag(array());
49        $this->assertIdentical($tag->getAttribute('href'), false);
50        $this->assertIdentical($tag->getHref(), '');
51    }
52   
53    function testIsIdMatchesIdAttribute() {
54        $tag = &new SimpleAnchorTag(array('href' => 'http://here/', 'id' => 7));
55        $this->assertIdentical($tag->getAttribute('id'), '7');
56        $this->assertTrue($tag->isId(7));
57    }
58}
59
60class TestOfWidget extends UnitTestCase {
61   
62    function testTextEmptyDefault() {
63        $tag = &new SimpleTextTag(array('type' => 'text'));
64        $this->assertIdentical($tag->getDefault(), '');
65        $this->assertIdentical($tag->getValue(), '');
66    }
67   
68    function testSettingOfExternalLabel() {
69        $tag = &new SimpleTextTag(array('type' => 'text'));
70        $tag->setLabel('it');
71        $this->assertTrue($tag->isLabel('it'));
72    }
73   
74    function testTextDefault() {
75        $tag = &new SimpleTextTag(array('value' => 'aaa'));
76        $this->assertEqual($tag->getDefault(), 'aaa');
77        $this->assertEqual($tag->getValue(), 'aaa');
78    }
79   
80    function testSettingTextValue() {
81        $tag = &new SimpleTextTag(array('value' => 'aaa'));
82        $tag->setValue('bbb');
83        $this->assertEqual($tag->getValue(), 'bbb');
84        $tag->resetValue();
85        $this->assertEqual($tag->getValue(), 'aaa');
86    }
87   
88    function testFailToSetHiddenValue() {
89        $tag = &new SimpleTextTag(array('value' => 'aaa', 'type' => 'hidden'));
90        $this->assertFalse($tag->setValue('bbb'));
91        $this->assertEqual($tag->getValue(), 'aaa');
92    }
93   
94    function testSubmitDefaults() {
95        $tag = &new SimpleSubmitTag(array('type' => 'submit'));
96        $this->assertIdentical($tag->getName(), false);
97        $this->assertEqual($tag->getValue(), 'Submit');
98        $this->assertFalse($tag->setValue('Cannot set this'));
99        $this->assertEqual($tag->getValue(), 'Submit');
100        $this->assertEqual($tag->getLabel(), 'Submit');
101       
102        $encoding = &new MockSimpleMultipartEncoding();
103        $encoding->expectNever('add');
104        $tag->write($encoding);
105    }
106   
107    function testPopulatedSubmit() {
108        $tag = &new SimpleSubmitTag(
109                array('type' => 'submit', 'name' => 's', 'value' => 'Ok!'));
110        $this->assertEqual($tag->getName(), 's');
111        $this->assertEqual($tag->getValue(), 'Ok!');
112        $this->assertEqual($tag->getLabel(), 'Ok!');
113       
114        $encoding = &new MockSimpleMultipartEncoding();
115        $encoding->expectOnce('add', array('s', 'Ok!'));
116        $tag->write($encoding);
117    }
118   
119    function testImageSubmit() {
120        $tag = &new SimpleImageSubmitTag(
121                array('type' => 'image', 'name' => 's', 'alt' => 'Label'));
122        $this->assertEqual($tag->getName(), 's');
123        $this->assertEqual($tag->getLabel(), 'Label');
124       
125        $encoding = &new MockSimpleMultipartEncoding();
126        $encoding->expectAt(0, 'add', array('s.x', 20));
127        $encoding->expectAt(1, 'add', array('s.y', 30));
128        $tag->write($encoding, 20, 30);
129    }
130   
131    function testImageSubmitTitlePreferredOverAltForLabel() {
132        $tag = &new SimpleImageSubmitTag(
133                array('type' => 'image', 'name' => 's', 'alt' => 'Label', 'title' => 'Title'));
134        $this->assertEqual($tag->getLabel(), 'Title');
135    }
136   
137    function testButton() {
138        $tag = &new SimpleButtonTag(
139                array('type' => 'submit', 'name' => 's', 'value' => 'do'));
140        $tag->addContent('I am a button');
141        $this->assertEqual($tag->getName(), 's');
142        $this->assertEqual($tag->getValue(), 'do');
143        $this->assertEqual($tag->getLabel(), 'I am a button');
144
145        $encoding = &new MockSimpleMultipartEncoding();
146        $encoding->expectOnce('add', array('s', 'do'));
147        $tag->write($encoding);
148    }
149}
150
151class TestOfTextArea extends UnitTestCase {
152   
153    function testDefault() {
154        $tag = &new SimpleTextAreaTag(array('name' => 'a'));
155        $tag->addContent('Some text');
156        $this->assertEqual($tag->getName(), 'a');
157        $this->assertEqual($tag->getDefault(), 'Some text');
158    }
159   
160    function testWrapping() {
161        $tag = &new SimpleTextAreaTag(array('cols' => '10', 'wrap' => 'physical'));
162        $tag->addContent("Lot's of text that should be wrapped");
163        $this->assertEqual(
164                $tag->getDefault(),
165                "Lot's of\r\ntext that\r\nshould be\r\nwrapped");
166        $tag->setValue("New long text\r\nwith two lines");
167        $this->assertEqual(
168                $tag->getValue(),
169                "New long\r\ntext\r\nwith two\r\nlines");
170    }
171   
172    function testWrappingRemovesLeadingcariageReturn() {
173        $tag = &new SimpleTextAreaTag(array('cols' => '20', 'wrap' => 'physical'));
174        $tag->addContent("\rStuff");
175        $this->assertEqual($tag->getDefault(), 'Stuff');
176        $tag->setValue("\nNew stuff\n");
177        $this->assertEqual($tag->getValue(), "New stuff\r\n");
178    }
179   
180    function testBreaksAreNewlineAndCarriageReturn() {
181        $tag = &new SimpleTextAreaTag(array('cols' => '10'));
182        $tag->addContent("Some\nText\rwith\r\nbreaks");
183        $this->assertEqual($tag->getValue(), "Some\r\nText\r\nwith\r\nbreaks");
184    }
185}
186
187class TestOfCheckbox extends UnitTestCase {
188   
189    function testCanSetCheckboxToNamedValueWithBooleanTrue() {
190        $tag = &new SimpleCheckboxTag(array('name' => 'a', 'value' => 'A'));
191        $this->assertEqual($tag->getValue(), false);
192        $tag->setValue(true);
193        $this->assertIdentical($tag->getValue(), 'A');
194    }
195}
196
197class TestOfSelection extends UnitTestCase {
198   
199    function testEmpty() {
200        $tag = &new SimpleSelectionTag(array('name' => 'a'));
201        $this->assertIdentical($tag->getValue(), '');
202    }
203   
204    function testSingle() {
205        $tag = &new SimpleSelectionTag(array('name' => 'a'));
206        $option = &new SimpleOptionTag(array());
207        $option->addContent('AAA');
208        $tag->addTag($option);
209        $this->assertEqual($tag->getValue(), 'AAA');
210    }
211   
212    function testSingleDefault() {
213        $tag = &new SimpleSelectionTag(array('name' => 'a'));
214        $option = &new SimpleOptionTag(array('selected' => ''));
215        $option->addContent('AAA');
216        $tag->addTag($option);
217        $this->assertEqual($tag->getValue(), 'AAA');
218    }
219   
220    function testSingleMappedDefault() {
221        $tag = &new SimpleSelectionTag(array('name' => 'a'));
222        $option = &new SimpleOptionTag(array('selected' => '', 'value' => 'aaa'));
223        $option->addContent('AAA');
224        $tag->addTag($option);
225        $this->assertEqual($tag->getValue(), 'aaa');
226    }
227   
228    function testStartsWithDefault() {
229        $tag = &new SimpleSelectionTag(array('name' => 'a'));
230        $a = &new SimpleOptionTag(array());
231        $a->addContent('AAA');
232        $tag->addTag($a);
233        $b = &new SimpleOptionTag(array('selected' => ''));
234        $b->addContent('BBB');
235        $tag->addTag($b);
236        $c = &new SimpleOptionTag(array());
237        $c->addContent('CCC');
238        $tag->addTag($c);
239        $this->assertEqual($tag->getValue(), 'BBB');
240    }
241   
242    function testSettingOption() {
243        $tag = &new SimpleSelectionTag(array('name' => 'a'));
244        $a = &new SimpleOptionTag(array());
245        $a->addContent('AAA');
246        $tag->addTag($a);
247        $b = &new SimpleOptionTag(array('selected' => ''));
248        $b->addContent('BBB');
249        $tag->addTag($b);
250        $c = &new SimpleOptionTag(array());
251        $c->addContent('CCC');
252        $tag->setValue('AAA');
253        $this->assertEqual($tag->getValue(), 'AAA');
254    }
255   
256    function testSettingMappedOption() {
257        $tag = &new SimpleSelectionTag(array('name' => 'a'));
258        $a = &new SimpleOptionTag(array('value' => 'aaa'));
259        $a->addContent('AAA');
260        $tag->addTag($a);
261        $b = &new SimpleOptionTag(array('value' => 'bbb', 'selected' => ''));
262        $b->addContent('BBB');
263        $tag->addTag($b);
264        $c = &new SimpleOptionTag(array('value' => 'ccc'));
265        $c->addContent('CCC');
266        $tag->addTag($c);
267        $tag->setValue('AAA');
268        $this->assertEqual($tag->getValue(), 'aaa');
269        $tag->setValue('ccc');
270        $this->assertEqual($tag->getValue(), 'ccc');
271    }
272   
273    function testSelectionDespiteSpuriousWhitespace() {
274        $tag = &new SimpleSelectionTag(array('name' => 'a'));
275        $a = &new SimpleOptionTag(array());
276        $a->addContent(' AAA ');
277        $tag->addTag($a);
278        $b = &new SimpleOptionTag(array('selected' => ''));
279        $b->addContent(' BBB ');
280        $tag->addTag($b);
281        $c = &new SimpleOptionTag(array());
282        $c->addContent(' CCC ');
283        $tag->addTag($c);
284        $this->assertEqual($tag->getValue(), ' BBB ');
285        $tag->setValue('AAA');
286        $this->assertEqual($tag->getValue(), ' AAA ');
287    }
288   
289    function testFailToSetIllegalOption() {
290        $tag = &new SimpleSelectionTag(array('name' => 'a'));
291        $a = &new SimpleOptionTag(array());
292        $a->addContent('AAA');
293        $tag->addTag($a);
294        $b = &new SimpleOptionTag(array('selected' => ''));
295        $b->addContent('BBB');
296        $tag->addTag($b);
297        $c = &new SimpleOptionTag(array());
298        $c->addContent('CCC');
299        $tag->addTag($c);
300        $this->assertFalse($tag->setValue('Not present'));
301        $this->assertEqual($tag->getValue(), 'BBB');
302    }
303   
304    function testNastyOptionValuesThatLookLikeFalse() {
305        $tag = &new SimpleSelectionTag(array('name' => 'a'));
306        $a = &new SimpleOptionTag(array('value' => '1'));
307        $a->addContent('One');
308        $tag->addTag($a);
309        $b = &new SimpleOptionTag(array('value' => '0'));
310        $b->addContent('Zero');
311        $tag->addTag($b);
312        $this->assertIdentical($tag->getValue(), '1');
313        $tag->setValue('Zero');
314        $this->assertIdentical($tag->getValue(), '0');
315    }
316   
317    function testBlankOption() {
318        $tag = &new SimpleSelectionTag(array('name' => 'A'));
319        $a = &new SimpleOptionTag(array());
320        $tag->addTag($a);
321        $b = &new SimpleOptionTag(array());
322        $b->addContent('b');
323        $tag->addTag($b);
324        $this->assertIdentical($tag->getValue(), '');
325        $tag->setValue('b');
326        $this->assertIdentical($tag->getValue(), 'b');
327        $tag->setValue('');
328        $this->assertIdentical($tag->getValue(), '');
329    }
330   
331    function testMultipleDefaultWithNoSelections() {
332        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
333        $a = &new SimpleOptionTag(array());
334        $a->addContent('AAA');
335        $tag->addTag($a);
336        $b = &new SimpleOptionTag(array());
337        $b->addContent('BBB');
338        $tag->addTag($b);
339        $this->assertIdentical($tag->getDefault(), array());
340        $this->assertIdentical($tag->getValue(), array());
341    }
342   
343    function testMultipleDefaultWithSelections() {
344        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
345        $a = &new SimpleOptionTag(array('selected' => ''));
346        $a->addContent('AAA');
347        $tag->addTag($a);
348        $b = &new SimpleOptionTag(array('selected' => ''));
349        $b->addContent('BBB');
350        $tag->addTag($b);
351        $this->assertIdentical($tag->getDefault(), array('AAA', 'BBB'));
352        $this->assertIdentical($tag->getValue(), array('AAA', 'BBB'));
353    }
354   
355    function testSettingMultiple() {
356        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
357        $a = &new SimpleOptionTag(array('selected' => ''));
358        $a->addContent('AAA');
359        $tag->addTag($a);
360        $b = &new SimpleOptionTag(array());
361        $b->addContent('BBB');
362        $tag->addTag($b);
363        $c = &new SimpleOptionTag(array('selected' => '', 'value' => 'ccc'));
364        $c->addContent('CCC');
365        $tag->addTag($c);
366        $this->assertIdentical($tag->getDefault(), array('AAA', 'ccc'));
367        $this->assertTrue($tag->setValue(array('BBB', 'ccc')));
368        $this->assertIdentical($tag->getValue(), array('BBB', 'ccc'));
369        $this->assertTrue($tag->setValue(array()));
370        $this->assertIdentical($tag->getValue(), array());
371    }
372   
373    function testFailToSetIllegalOptionsInMultiple() {
374        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
375        $a = &new SimpleOptionTag(array('selected' => ''));
376        $a->addContent('AAA');
377        $tag->addTag($a);
378        $b = &new SimpleOptionTag(array());
379        $b->addContent('BBB');
380        $tag->addTag($b);
381        $this->assertFalse($tag->setValue(array('CCC')));
382        $this->assertTrue($tag->setValue(array('AAA', 'BBB')));
383        $this->assertFalse($tag->setValue(array('AAA', 'CCC')));
384    }
385}
386
387class TestOfRadioGroup extends UnitTestCase {
388   
389    function testEmptyGroup() {
390        $group = &new SimpleRadioGroup();
391        $this->assertIdentical($group->getDefault(), false);
392        $this->assertIdentical($group->getValue(), false);
393        $this->assertFalse($group->setValue('a'));
394    }
395   
396    function testReadingSingleButtonGroup() {
397        $group = &new SimpleRadioGroup();
398        $group->addWidget(new SimpleRadioButtonTag(
399                array('value' => 'A', 'checked' => '')));
400        $this->assertIdentical($group->getDefault(), 'A');
401        $this->assertIdentical($group->getValue(), 'A');
402    }
403   
404    function testReadingMultipleButtonGroup() {
405        $group = &new SimpleRadioGroup();
406        $group->addWidget(new SimpleRadioButtonTag(
407                array('value' => 'A')));
408        $group->addWidget(new SimpleRadioButtonTag(
409                array('value' => 'B', 'checked' => '')));
410        $this->assertIdentical($group->getDefault(), 'B');
411        $this->assertIdentical($group->getValue(), 'B');
412    }
413   
414    function testFailToSetUnlistedValue() {
415        $group = &new SimpleRadioGroup();
416        $group->addWidget(new SimpleRadioButtonTag(array('value' => 'z')));
417        $this->assertFalse($group->setValue('a'));
418        $this->assertIdentical($group->getValue(), false);
419    }
420   
421    function testSettingNewValueClearsTheOldOne() {
422        $group = &new SimpleRadioGroup();
423        $group->addWidget(new SimpleRadioButtonTag(
424                array('value' => 'A')));
425        $group->addWidget(new SimpleRadioButtonTag(
426                array('value' => 'B', 'checked' => '')));
427        $this->assertTrue($group->setValue('A'));
428        $this->assertIdentical($group->getValue(), 'A');
429    }
430   
431    function testIsIdMatchesAnyWidgetInSet() {
432        $group = &new SimpleRadioGroup();
433        $group->addWidget(new SimpleRadioButtonTag(
434                array('value' => 'A', 'id' => 'i1')));
435        $group->addWidget(new SimpleRadioButtonTag(
436                array('value' => 'B', 'id' => 'i2')));
437        $this->assertFalse($group->isId('i0'));
438        $this->assertTrue($group->isId('i1'));
439        $this->assertTrue($group->isId('i2'));
440    }
441   
442    function testIsLabelMatchesAnyWidgetInSet() {
443        $group = &new SimpleRadioGroup();
444        $button1 = &new SimpleRadioButtonTag(array('value' => 'A'));
445        $button1->setLabel('one');
446        $group->addWidget($button1);
447        $button2 = &new SimpleRadioButtonTag(array('value' => 'B'));
448        $button2->setLabel('two');
449        $group->addWidget($button2);
450        $this->assertFalse($group->isLabel('three'));
451        $this->assertTrue($group->isLabel('one'));
452        $this->assertTrue($group->isLabel('two'));
453    }
454}
455
456class TestOfTagGroup extends UnitTestCase {
457   
458    function testReadingMultipleCheckboxGroup() {
459        $group = &new SimpleCheckboxGroup();
460        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
461        $group->addWidget(new SimpleCheckboxTag(
462                array('value' => 'B', 'checked' => '')));
463        $this->assertIdentical($group->getDefault(), 'B');
464        $this->assertIdentical($group->getValue(), 'B');
465    }
466   
467    function testReadingMultipleUncheckedItems() {
468        $group = &new SimpleCheckboxGroup();
469        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
470        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));           
471        $this->assertIdentical($group->getDefault(), false);
472        $this->assertIdentical($group->getValue(), false);
473    }
474   
475    function testReadingMultipleCheckedItems() {
476        $group = &new SimpleCheckboxGroup();
477        $group->addWidget(new SimpleCheckboxTag(
478                array('value' => 'A', 'checked' => '')));
479        $group->addWidget(new SimpleCheckboxTag(
480                array('value' => 'B', 'checked' => '')));
481        $this->assertIdentical($group->getDefault(), array('A', 'B'));
482        $this->assertIdentical($group->getValue(), array('A', 'B'));
483    }
484   
485    function testSettingSingleValue() {
486        $group = &new SimpleCheckboxGroup();
487        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
488        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
489        $this->assertTrue($group->setValue('A'));
490        $this->assertIdentical($group->getValue(), 'A');
491        $this->assertTrue($group->setValue('B'));
492        $this->assertIdentical($group->getValue(), 'B');
493    }
494   
495    function testSettingMultipleValues() {
496        $group = &new SimpleCheckboxGroup();
497        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
498        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
499        $this->assertTrue($group->setValue(array('A', 'B')));
500        $this->assertIdentical($group->getValue(), array('A', 'B'));
501    }
502   
503    function testSettingNoValue() {
504        $group = &new SimpleCheckboxGroup();
505        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
506        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
507        $this->assertTrue($group->setValue(false));
508        $this->assertIdentical($group->getValue(), false);
509    }
510   
511    function testIsIdMatchesAnyIdInSet() {
512        $group = &new SimpleCheckboxGroup();
513        $group->addWidget(new SimpleCheckboxTag(array('id' => 1, 'value' => 'A')));
514        $group->addWidget(new SimpleCheckboxTag(array('id' => 2, 'value' => 'B')));
515        $this->assertFalse($group->isId(0));
516        $this->assertTrue($group->isId(1));
517        $this->assertTrue($group->isId(2));
518    }
519}
520
521class TestOfUploadWidget extends UnitTestCase {
522   
523    function testValueIsFilePath() {
524        $upload = &new SimpleUploadTag(array('name' => 'a'));
525        $upload->setValue(dirname(__FILE__) . '/support/upload_sample.txt');
526        $this->assertEqual($upload->getValue(), dirname(__FILE__) . '/support/upload_sample.txt');
527    }
528   
529    function testSubmitsFileContents() {
530        $encoding = &new MockSimpleMultipartEncoding();
531        $encoding->expectOnce('attach', array(
532                'a',
533                'Sample for testing file upload',
534                'upload_sample.txt'));
535        $upload = &new SimpleUploadTag(array('name' => 'a'));
536        $upload->setValue(dirname(__FILE__) . '/support/upload_sample.txt');
537        $upload->write($encoding);
538    }
539}
540
541class TestOfLabelTag extends UnitTestCase {
542   
543    function testLabelShouldHaveAnEndTag() {
544        $label = &new SimpleLabelTag(array());
545        $this->assertTrue($label->expectEndTag());
546    }
547   
548    function testContentIsTextOnly() {
549        $label = &new SimpleLabelTag(array());
550        $label->addContent('Here <tag>are</tag> words');
551        $this->assertEqual($label->getText(), 'Here are words');
552    }
553}
554?>
Note: See TracBrowser for help on using the repository browser.