From 322bb9cd2be9e51422cb2b82684692e825c2bfb7 Mon Sep 17 00:00:00 2001
From: brettp <brettp@36083f99-b078-4883-b0ff-0f9b5a30f544>
Date: Fri, 2 Oct 2009 18:40:04 +0000
Subject: Added simpletest and start of unit tests.

git-svn-id: http://code.elgg.org/elgg/trunk@3503 36083f99-b078-4883-b0ff-0f9b5a30f544
---
 vendors/simpletest/test/tag_test.php | 554 +++++++++++++++++++++++++++++++++++
 1 file changed, 554 insertions(+)
 create mode 100755 vendors/simpletest/test/tag_test.php

(limited to 'vendors/simpletest/test/tag_test.php')

diff --git a/vendors/simpletest/test/tag_test.php b/vendors/simpletest/test/tag_test.php
new file mode 100755
index 000000000..f81df64ea
--- /dev/null
+++ b/vendors/simpletest/test/tag_test.php
@@ -0,0 +1,554 @@
+<?php
+// $Id: tag_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../tag.php');
+require_once(dirname(__FILE__) . '/../encoding.php');
+Mock::generate('SimpleMultipartEncoding');
+
+class TestOfTag extends UnitTestCase {
+    
+    function testStartValuesWithoutAdditionalContent() {
+        $tag = new SimpleTitleTag(array('a' => '1', 'b' => ''));
+        $this->assertEqual($tag->getTagName(), 'title');
+        $this->assertIdentical($tag->getAttribute('a'), '1');
+        $this->assertIdentical($tag->getAttribute('b'), '');
+        $this->assertIdentical($tag->getAttribute('c'), false);
+        $this->assertIdentical($tag->getContent(), '');
+    }
+    
+    function testTitleContent() {
+        $tag = &new SimpleTitleTag(array());
+        $this->assertTrue($tag->expectEndTag());
+        $tag->addContent('Hello');
+        $tag->addContent('World');
+        $this->assertEqual($tag->getText(), 'HelloWorld');
+    }
+    
+    function testMessyTitleContent() {
+        $tag = &new SimpleTitleTag(array());
+        $this->assertTrue($tag->expectEndTag());
+        $tag->addContent('<b>Hello</b>');
+        $tag->addContent('<em>World</em>');
+        $this->assertEqual($tag->getText(), 'HelloWorld');
+    }
+    
+    function testTagWithNoEnd() {
+        $tag = &new SimpleTextTag(array());
+        $this->assertFalse($tag->expectEndTag());
+    }
+    
+    function testAnchorHref() {
+        $tag = &new SimpleAnchorTag(array('href' => 'http://here/'));
+        $this->assertEqual($tag->getHref(), 'http://here/');
+        
+        $tag = &new SimpleAnchorTag(array('href' => ''));
+        $this->assertIdentical($tag->getAttribute('href'), '');
+        $this->assertIdentical($tag->getHref(), '');
+        
+        $tag = &new SimpleAnchorTag(array());
+        $this->assertIdentical($tag->getAttribute('href'), false);
+        $this->assertIdentical($tag->getHref(), '');
+    }
+    
+    function testIsIdMatchesIdAttribute() {
+        $tag = &new SimpleAnchorTag(array('href' => 'http://here/', 'id' => 7));
+        $this->assertIdentical($tag->getAttribute('id'), '7');
+        $this->assertTrue($tag->isId(7));
+    }
+}
+
+class TestOfWidget extends UnitTestCase {
+    
+    function testTextEmptyDefault() {
+        $tag = &new SimpleTextTag(array('type' => 'text'));
+        $this->assertIdentical($tag->getDefault(), '');
+        $this->assertIdentical($tag->getValue(), '');
+    }
+    
+    function testSettingOfExternalLabel() {
+        $tag = &new SimpleTextTag(array('type' => 'text'));
+        $tag->setLabel('it');
+        $this->assertTrue($tag->isLabel('it'));
+    }
+    
+    function testTextDefault() {
+        $tag = &new SimpleTextTag(array('value' => 'aaa'));
+        $this->assertEqual($tag->getDefault(), 'aaa');
+        $this->assertEqual($tag->getValue(), 'aaa');
+    }
+    
+    function testSettingTextValue() {
+        $tag = &new SimpleTextTag(array('value' => 'aaa'));
+        $tag->setValue('bbb');
+        $this->assertEqual($tag->getValue(), 'bbb');
+        $tag->resetValue();
+        $this->assertEqual($tag->getValue(), 'aaa');
+    }
+    
+    function testFailToSetHiddenValue() {
+        $tag = &new SimpleTextTag(array('value' => 'aaa', 'type' => 'hidden'));
+        $this->assertFalse($tag->setValue('bbb'));
+        $this->assertEqual($tag->getValue(), 'aaa');
+    }
+    
+    function testSubmitDefaults() {
+        $tag = &new SimpleSubmitTag(array('type' => 'submit'));
+        $this->assertIdentical($tag->getName(), false);
+        $this->assertEqual($tag->getValue(), 'Submit');
+        $this->assertFalse($tag->setValue('Cannot set this'));
+        $this->assertEqual($tag->getValue(), 'Submit');
+        $this->assertEqual($tag->getLabel(), 'Submit');
+        
+        $encoding = &new MockSimpleMultipartEncoding();
+        $encoding->expectNever('add');
+        $tag->write($encoding);
+    }
+    
+    function testPopulatedSubmit() {
+        $tag = &new SimpleSubmitTag(
+                array('type' => 'submit', 'name' => 's', 'value' => 'Ok!'));
+        $this->assertEqual($tag->getName(), 's');
+        $this->assertEqual($tag->getValue(), 'Ok!');
+        $this->assertEqual($tag->getLabel(), 'Ok!');
+        
+        $encoding = &new MockSimpleMultipartEncoding();
+        $encoding->expectOnce('add', array('s', 'Ok!'));
+        $tag->write($encoding);
+    }
+    
+    function testImageSubmit() {
+        $tag = &new SimpleImageSubmitTag(
+                array('type' => 'image', 'name' => 's', 'alt' => 'Label'));
+        $this->assertEqual($tag->getName(), 's');
+        $this->assertEqual($tag->getLabel(), 'Label');
+        
+        $encoding = &new MockSimpleMultipartEncoding();
+        $encoding->expectAt(0, 'add', array('s.x', 20));
+        $encoding->expectAt(1, 'add', array('s.y', 30));
+        $tag->write($encoding, 20, 30);
+    }
+    
+    function testImageSubmitTitlePreferredOverAltForLabel() {
+        $tag = &new SimpleImageSubmitTag(
+                array('type' => 'image', 'name' => 's', 'alt' => 'Label', 'title' => 'Title'));
+        $this->assertEqual($tag->getLabel(), 'Title');
+    }
+    
+    function testButton() {
+        $tag = &new SimpleButtonTag(
+                array('type' => 'submit', 'name' => 's', 'value' => 'do'));
+        $tag->addContent('I am a button');
+        $this->assertEqual($tag->getName(), 's');
+        $this->assertEqual($tag->getValue(), 'do');
+        $this->assertEqual($tag->getLabel(), 'I am a button');
+
+        $encoding = &new MockSimpleMultipartEncoding();
+        $encoding->expectOnce('add', array('s', 'do'));
+        $tag->write($encoding);
+    }
+}
+
+class TestOfTextArea extends UnitTestCase {
+    
+    function testDefault() {
+        $tag = &new SimpleTextAreaTag(array('name' => 'a'));
+        $tag->addContent('Some text');
+        $this->assertEqual($tag->getName(), 'a');
+        $this->assertEqual($tag->getDefault(), 'Some text');
+    }
+    
+    function testWrapping() {
+        $tag = &new SimpleTextAreaTag(array('cols' => '10', 'wrap' => 'physical'));
+        $tag->addContent("Lot's of text that should be wrapped");
+        $this->assertEqual(
+                $tag->getDefault(),
+                "Lot's of\r\ntext that\r\nshould be\r\nwrapped");
+        $tag->setValue("New long text\r\nwith two lines");
+        $this->assertEqual(
+                $tag->getValue(),
+                "New long\r\ntext\r\nwith two\r\nlines");
+    }
+    
+    function testWrappingRemovesLeadingcariageReturn() {
+        $tag = &new SimpleTextAreaTag(array('cols' => '20', 'wrap' => 'physical'));
+        $tag->addContent("\rStuff");
+        $this->assertEqual($tag->getDefault(), 'Stuff');
+        $tag->setValue("\nNew stuff\n");
+        $this->assertEqual($tag->getValue(), "New stuff\r\n");
+    }
+    
+    function testBreaksAreNewlineAndCarriageReturn() {
+        $tag = &new SimpleTextAreaTag(array('cols' => '10'));
+        $tag->addContent("Some\nText\rwith\r\nbreaks");
+        $this->assertEqual($tag->getValue(), "Some\r\nText\r\nwith\r\nbreaks");
+    }
+}
+
+class TestOfCheckbox extends UnitTestCase {
+    
+    function testCanSetCheckboxToNamedValueWithBooleanTrue() {
+        $tag = &new SimpleCheckboxTag(array('name' => 'a', 'value' => 'A'));
+        $this->assertEqual($tag->getValue(), false);
+        $tag->setValue(true);
+        $this->assertIdentical($tag->getValue(), 'A');
+    }
+}
+
+class TestOfSelection extends UnitTestCase {
+    
+    function testEmpty() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $this->assertIdentical($tag->getValue(), '');
+    }
+    
+    function testSingle() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $option = &new SimpleOptionTag(array());
+        $option->addContent('AAA');
+        $tag->addTag($option);
+        $this->assertEqual($tag->getValue(), 'AAA');
+    }
+    
+    function testSingleDefault() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $option = &new SimpleOptionTag(array('selected' => ''));
+        $option->addContent('AAA');
+        $tag->addTag($option);
+        $this->assertEqual($tag->getValue(), 'AAA');
+    }
+    
+    function testSingleMappedDefault() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $option = &new SimpleOptionTag(array('selected' => '', 'value' => 'aaa'));
+        $option->addContent('AAA');
+        $tag->addTag($option);
+        $this->assertEqual($tag->getValue(), 'aaa');
+    }
+    
+    function testStartsWithDefault() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $a = &new SimpleOptionTag(array());
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('selected' => ''));
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $c = &new SimpleOptionTag(array());
+        $c->addContent('CCC');
+        $tag->addTag($c);
+        $this->assertEqual($tag->getValue(), 'BBB');
+    }
+    
+    function testSettingOption() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $a = &new SimpleOptionTag(array());
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('selected' => ''));
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $c = &new SimpleOptionTag(array());
+        $c->addContent('CCC');
+        $tag->setValue('AAA');
+        $this->assertEqual($tag->getValue(), 'AAA');
+    }
+    
+    function testSettingMappedOption() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $a = &new SimpleOptionTag(array('value' => 'aaa'));
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('value' => 'bbb', 'selected' => ''));
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $c = &new SimpleOptionTag(array('value' => 'ccc'));
+        $c->addContent('CCC');
+        $tag->addTag($c);
+        $tag->setValue('AAA');
+        $this->assertEqual($tag->getValue(), 'aaa');
+        $tag->setValue('ccc');
+        $this->assertEqual($tag->getValue(), 'ccc');
+    }
+    
+    function testSelectionDespiteSpuriousWhitespace() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $a = &new SimpleOptionTag(array());
+        $a->addContent(' AAA ');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('selected' => ''));
+        $b->addContent(' BBB ');
+        $tag->addTag($b);
+        $c = &new SimpleOptionTag(array());
+        $c->addContent(' CCC ');
+        $tag->addTag($c);
+        $this->assertEqual($tag->getValue(), ' BBB ');
+        $tag->setValue('AAA');
+        $this->assertEqual($tag->getValue(), ' AAA ');
+    }
+    
+    function testFailToSetIllegalOption() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $a = &new SimpleOptionTag(array());
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('selected' => ''));
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $c = &new SimpleOptionTag(array());
+        $c->addContent('CCC');
+        $tag->addTag($c);
+        $this->assertFalse($tag->setValue('Not present'));
+        $this->assertEqual($tag->getValue(), 'BBB');
+    }
+    
+    function testNastyOptionValuesThatLookLikeFalse() {
+        $tag = &new SimpleSelectionTag(array('name' => 'a'));
+        $a = &new SimpleOptionTag(array('value' => '1'));
+        $a->addContent('One');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('value' => '0'));
+        $b->addContent('Zero');
+        $tag->addTag($b);
+        $this->assertIdentical($tag->getValue(), '1');
+        $tag->setValue('Zero');
+        $this->assertIdentical($tag->getValue(), '0');
+    }
+    
+    function testBlankOption() {
+        $tag = &new SimpleSelectionTag(array('name' => 'A'));
+        $a = &new SimpleOptionTag(array());
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array());
+        $b->addContent('b');
+        $tag->addTag($b);
+        $this->assertIdentical($tag->getValue(), '');
+        $tag->setValue('b');
+        $this->assertIdentical($tag->getValue(), 'b');
+        $tag->setValue('');
+        $this->assertIdentical($tag->getValue(), '');
+    }
+    
+    function testMultipleDefaultWithNoSelections() {
+        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
+        $a = &new SimpleOptionTag(array());
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array());
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $this->assertIdentical($tag->getDefault(), array());
+        $this->assertIdentical($tag->getValue(), array());
+    }
+    
+    function testMultipleDefaultWithSelections() {
+        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
+        $a = &new SimpleOptionTag(array('selected' => ''));
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array('selected' => ''));
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $this->assertIdentical($tag->getDefault(), array('AAA', 'BBB'));
+        $this->assertIdentical($tag->getValue(), array('AAA', 'BBB'));
+    }
+    
+    function testSettingMultiple() {
+        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
+        $a = &new SimpleOptionTag(array('selected' => ''));
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array());
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $c = &new SimpleOptionTag(array('selected' => '', 'value' => 'ccc'));
+        $c->addContent('CCC');
+        $tag->addTag($c);
+        $this->assertIdentical($tag->getDefault(), array('AAA', 'ccc'));
+        $this->assertTrue($tag->setValue(array('BBB', 'ccc')));
+        $this->assertIdentical($tag->getValue(), array('BBB', 'ccc'));
+        $this->assertTrue($tag->setValue(array()));
+        $this->assertIdentical($tag->getValue(), array());
+    }
+    
+    function testFailToSetIllegalOptionsInMultiple() {
+        $tag = &new MultipleSelectionTag(array('name' => 'a', 'multiple' => ''));
+        $a = &new SimpleOptionTag(array('selected' => ''));
+        $a->addContent('AAA');
+        $tag->addTag($a);
+        $b = &new SimpleOptionTag(array());
+        $b->addContent('BBB');
+        $tag->addTag($b);
+        $this->assertFalse($tag->setValue(array('CCC')));
+        $this->assertTrue($tag->setValue(array('AAA', 'BBB')));
+        $this->assertFalse($tag->setValue(array('AAA', 'CCC')));
+    }
+}
+
+class TestOfRadioGroup extends UnitTestCase {
+    
+    function testEmptyGroup() {
+        $group = &new SimpleRadioGroup();
+        $this->assertIdentical($group->getDefault(), false);
+        $this->assertIdentical($group->getValue(), false);
+        $this->assertFalse($group->setValue('a'));
+    }
+    
+    function testReadingSingleButtonGroup() {
+        $group = &new SimpleRadioGroup();
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'A', 'checked' => '')));
+        $this->assertIdentical($group->getDefault(), 'A');
+        $this->assertIdentical($group->getValue(), 'A');
+    }
+    
+    function testReadingMultipleButtonGroup() {
+        $group = &new SimpleRadioGroup();
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'A')));
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'B', 'checked' => '')));
+        $this->assertIdentical($group->getDefault(), 'B');
+        $this->assertIdentical($group->getValue(), 'B');
+    }
+    
+    function testFailToSetUnlistedValue() {
+        $group = &new SimpleRadioGroup();
+        $group->addWidget(new SimpleRadioButtonTag(array('value' => 'z')));
+        $this->assertFalse($group->setValue('a'));
+        $this->assertIdentical($group->getValue(), false);
+    }
+    
+    function testSettingNewValueClearsTheOldOne() {
+        $group = &new SimpleRadioGroup();
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'A')));
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'B', 'checked' => '')));
+        $this->assertTrue($group->setValue('A'));
+        $this->assertIdentical($group->getValue(), 'A');
+    }
+    
+    function testIsIdMatchesAnyWidgetInSet() {
+        $group = &new SimpleRadioGroup();
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'A', 'id' => 'i1')));
+        $group->addWidget(new SimpleRadioButtonTag(
+                array('value' => 'B', 'id' => 'i2')));
+        $this->assertFalse($group->isId('i0'));
+        $this->assertTrue($group->isId('i1'));
+        $this->assertTrue($group->isId('i2'));
+    }
+    
+    function testIsLabelMatchesAnyWidgetInSet() {
+        $group = &new SimpleRadioGroup();
+        $button1 = &new SimpleRadioButtonTag(array('value' => 'A'));
+        $button1->setLabel('one');
+        $group->addWidget($button1);
+        $button2 = &new SimpleRadioButtonTag(array('value' => 'B'));
+        $button2->setLabel('two');
+        $group->addWidget($button2);
+        $this->assertFalse($group->isLabel('three'));
+        $this->assertTrue($group->isLabel('one'));
+        $this->assertTrue($group->isLabel('two'));
+    }
+}
+
+class TestOfTagGroup extends UnitTestCase {
+    
+    function testReadingMultipleCheckboxGroup() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
+        $group->addWidget(new SimpleCheckboxTag(
+                array('value' => 'B', 'checked' => '')));
+        $this->assertIdentical($group->getDefault(), 'B');
+        $this->assertIdentical($group->getValue(), 'B');
+    }
+    
+    function testReadingMultipleUncheckedItems() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));            
+        $this->assertIdentical($group->getDefault(), false);
+        $this->assertIdentical($group->getValue(), false);
+    }
+    
+    function testReadingMultipleCheckedItems() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(
+                array('value' => 'A', 'checked' => '')));
+        $group->addWidget(new SimpleCheckboxTag(
+                array('value' => 'B', 'checked' => '')));
+        $this->assertIdentical($group->getDefault(), array('A', 'B'));
+        $this->assertIdentical($group->getValue(), array('A', 'B'));
+    }
+    
+    function testSettingSingleValue() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
+        $this->assertTrue($group->setValue('A'));
+        $this->assertIdentical($group->getValue(), 'A');
+        $this->assertTrue($group->setValue('B'));
+        $this->assertIdentical($group->getValue(), 'B');
+    }
+    
+    function testSettingMultipleValues() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
+        $this->assertTrue($group->setValue(array('A', 'B')));
+        $this->assertIdentical($group->getValue(), array('A', 'B'));
+    }
+    
+    function testSettingNoValue() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'A')));
+        $group->addWidget(new SimpleCheckboxTag(array('value' => 'B')));
+        $this->assertTrue($group->setValue(false));
+        $this->assertIdentical($group->getValue(), false);
+    }
+    
+    function testIsIdMatchesAnyIdInSet() {
+        $group = &new SimpleCheckboxGroup();
+        $group->addWidget(new SimpleCheckboxTag(array('id' => 1, 'value' => 'A')));
+        $group->addWidget(new SimpleCheckboxTag(array('id' => 2, 'value' => 'B')));
+        $this->assertFalse($group->isId(0));
+        $this->assertTrue($group->isId(1));
+        $this->assertTrue($group->isId(2));
+    }
+}
+
+class TestOfUploadWidget extends UnitTestCase {
+    
+    function testValueIsFilePath() {
+        $upload = &new SimpleUploadTag(array('name' => 'a'));
+        $upload->setValue(dirname(__FILE__) . '/support/upload_sample.txt');
+        $this->assertEqual($upload->getValue(), dirname(__FILE__) . '/support/upload_sample.txt');
+    }
+    
+    function testSubmitsFileContents() {
+        $encoding = &new MockSimpleMultipartEncoding();
+        $encoding->expectOnce('attach', array(
+                'a',
+                'Sample for testing file upload',
+                'upload_sample.txt'));
+        $upload = &new SimpleUploadTag(array('name' => 'a'));
+        $upload->setValue(dirname(__FILE__) . '/support/upload_sample.txt');
+        $upload->write($encoding);
+    }
+}
+
+class TestOfLabelTag extends UnitTestCase {
+    
+    function testLabelShouldHaveAnEndTag() {
+        $label = &new SimpleLabelTag(array());
+        $this->assertTrue($label->expectEndTag());
+    }
+    
+    function testContentIsTextOnly() {
+        $label = &new SimpleLabelTag(array());
+        $label->addContent('Here <tag>are</tag> words');
+        $this->assertEqual($label->getText(), 'Here are words');
+    }
+}
+?>
\ No newline at end of file
-- 
cgit v1.2.3